def __init__(self, **kwargs):
    """ Initializes a AddressRange instance
        Notes:
            You can specify all parameters while calling this methods.
            A special argument named `data` will enable you to load the
            object from a Python dictionary
        Examples:
            >>> addressrange = NUAddressRange(id=u'xxxx-xxx-xxx-xxx', name=u'AddressRange')
            >>> addressrange = NUAddressRange(data=my_dict)
    """
    super(NUAddressRange, self).__init__()
    # Read/Write Attributes
    
    self._dhcp_pool_type = None
    self._last_updated_by = None
    self._max_address = None
    self._min_address = None
    self._entity_scope = None
    self._external_id = None
    
    self.expose_attribute(local_name="dhcp_pool_type", remote_name="DHCPPoolType", attribute_type=str, is_required=False, is_unique=False, choices=[u'BRIDGE', u'HOST'])
    self.expose_attribute(local_name="last_updated_by", remote_name="lastUpdatedBy", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="max_address", remote_name="maxAddress", attribute_type=str, is_required=True, is_unique=False)
    self.expose_attribute(local_name="min_address", remote_name="minAddress", attribute_type=str, is_required=True, is_unique=False)
    self.expose_attribute(local_name="entity_scope", remote_name="entityScope", attribute_type=str, is_required=False, is_unique=False, choices=[u'ENTERPRISE', u'GLOBAL'])
    self.expose_attribute(local_name="external_id", remote_name="externalID", attribute_type=str, is_required=False, is_unique=True)
    
    # Fetchers
    
    
    self.metadatas = NUMetadatasFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.global_metadatas = NUGlobalMetadatasFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.event_logs = NUEventLogsFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    self._compute_args(**kwargs)

def add_child(self, child):
    """ Add a child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    if children is None:
        raise InternalConsitencyError('Could not find fetcher with name %s while adding %s in parent %s' % (rest_name, child, self))
    if child not in children:
        child.parent_object = self
        children.append(child)

def assign(self, objects, nurest_object_type, async=False, callback=None, commit=True):
    """ Reference a list of objects into the current resource
        Args:
            objects (list): list of NURESTObject to link
            nurest_object_type (type): Type of the object to link
            callback (function): Callback method that should be fired at the end
        Returns:
            Returns the current object and the connection (object, connection)
        Example:
            >>> entity.assign([entity1, entity2, entity3], NUEntity) # entity1, entity2 and entity3 are now part of the entity
    """
    ids = list()
    for nurest_object in objects:
        ids.append(nurest_object.id)
    url = self.get_resource_url_for_child_type(nurest_object_type)
    request = NURESTRequest(method=HTTP_METHOD_PUT, url=url, data=ids)
    user_info = {'nurest_objects': objects, 'commit': commit}
    if async:
        return self.send_request(request=request,
                                 async=async,
                                 local_callback=self._did_perform_standard_operation,
                                 remote_callback=callback,
                                 user_info=user_info)
    else:
        connection = self.send_request(request=request,
                                       user_info=user_info)
        return self._did_perform_standard_operation(connection)

def copy(self):
    """ Returns a copy of the current object
        Returns:
            A copy of the given object
        Example::
            >>> print entity.to_dict()
            
    """
    return self.__class__(data=self.to_dict())

def create_child(self, nurest_object, response_choice=None, async=False, callback=None, commit=True):
    """ Add given nurest_object to the current object
        For example, to add a child into a parent, you can call
        parent.create_child(nurest_object=child)
        Args:
            nurest_object (bambou.NURESTObject): the NURESTObject object to add
            response_choice (int): Automatically send a response choice when confirmation is needed
            async (bool): should the request be done asynchronously or not
            callback (function): callback containing the object and the connection
        Returns:
            Returns the object and connection (object, connection)
        Example:
            >>> entity = NUEntity(name="Super Entity")
            >>> parent_entity.create_child(entity) # the new entity as been created in the parent_entity
    """
    # if nurest_object.id:
    #     raise InternalConsitencyError("Cannot create a child that already has an ID: %s." % nurest_object)
    return self._manage_child_object(nurest_object=nurest_object,
                                     async=async,
                                     method=HTTP_METHOD_POST,
                                     callback=callback,
                                     handler=self._did_create_child,
                                     response_choice=response_choice,
                                     commit=commit)

def delete(self, response_choice=1, async=False, callback=None):
    """ Delete object and call given callback in case of call.
        Args:
            response_choice (int): Automatically send a response choice when confirmation is needed
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Example:
            >>> entity.delete() # will delete the enterprise from the server
    """
    return self._manage_child_object(nurest_object=self, method=HTTP_METHOD_DELETE, async=async, callback=callback, response_choice=response_choice)

def equals(self, rest_object):
    """ Compare with another object """
    if self._is_dirty:
        return False
    if rest_object is None:
        return False
    if not isinstance(rest_object, NURESTObject):
        raise TypeError('The object is not a NURESTObject %s' % rest_object)
    if self.rest_name != rest_object.rest_name:
        return False
    if self.id and rest_object.id:
        return self.id == rest_object.id
    if self.local_id and rest_object.local_id:
        return self.local_id == rest_object.local_id
    return False

def expose_attribute(self, local_name, attribute_type, remote_name=None, display_name=None, is_required=False, is_readonly=False, max_length=None, min_length=None, is_identifier=False, choices=None, is_unique=False, is_email=False, is_login=False, is_editable=True, is_password=False, can_order=False, can_search=False):
    """ Expose local_name as remote_name
        An exposed attribute `local_name` will be sent within the HTTP request as
        a `remote_name`
    """
    if remote_name is None:
        remote_name = local_name
    if display_name is None:
        display_name = local_name
    attribute = NURemoteAttribute(local_name=local_name, remote_name=remote_name, attribute_type=attribute_type)
    attribute.display_name = display_name
    attribute.is_required = is_required
    attribute.is_readonly = is_readonly
    attribute.min_length = min_length
    attribute.max_length = max_length
    attribute.is_editable = is_editable
    attribute.is_identifier = is_identifier
    attribute.choices = choices
    attribute.is_unique = is_unique
    attribute.is_email = is_email
    attribute.is_login = is_login
    attribute.is_password = is_password
    attribute.can_order = can_order
    attribute.can_search = can_search
    self._attributes[local_name] = attribute

def fetch(self, async=False, callback=None):
    """ Fetch all information about the current object
        Args:
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Returns:
            tuple: (current_fetcher, callee_parent, fetched_bjects, connection)
        Example:
            >>> entity = NUEntity(id="xxx-xxx-xxx-xxx")
            >>> entity.fetch() # will get the entity with id "xxx-xxx-xxx-xxx"
            >>> print entity.name
            "My Entity"
    """
    if self.id is None:
        raise InternalConsitencyError("Cannot fetch an object that does not have an ID")
    request = NURESTRequest(method=HTTP_METHOD_GET, url=self.get_resource_url())
    if async:
        return self.send_request(request=request, async=async, local_callback=self._did_retrieve, remote_callback=callback)
    else:
        connection = self.send_request(request=request)
        return self._did_retrieve(connection)

def fetcher_for_rest_name(self, rest_name):
    """ Returns the children fetcher for the given rest name
        Args:
            rest_name (string): the children rest name
        Returns:
            list: Returns the corresponding fetcher
        Example:
            >>> print entity.fetcher_for_rest_name(NUSubEntity.rest_name)
            
    """
    if rest_name not in self._fetchers_registry:
        return None
    return self._fetchers_registry[rest_name]

def from_dict(self, dictionary):
    """ Sets all the exposed ReST attribues from the given dictionary
        Args:
            dictionary (dict): dictionnary containing the raw object attributes and their values.
        Example:
            >>> info = {"name": "my group", "private": False}
            >>> group = NUGroup()
            >>> group.from_dict(info)
            >>> print "name: %s - private: %s" % (group.name, group.private)
            "name: my group - private: False"
    """
    for remote_name, remote_value in dictionary.iteritems():
        # Check if a local attribute is exposed with the remote_name
        # if no attribute is exposed, return None
        local_name = next((name for name, attribute in self._attributes.iteritems() if attribute.remote_name == remote_name), None)
        if local_name:
            setattr(self, local_name, remote_value)
        else:
            # print('Attribute %s could not be added to object %s' % (remote_name, self))
            pass  # pragma: no cover

def genealogic_ids(self):
    """ Get all genealogic ids
        Returns:
             A list of all parent ids
    """
    ids = []
    parent = self
    while parent:
        ids.append(parent.id)
        parent = parent.parent_object
    return ids

def genealogic_types(self):
    """ Get genealogic types
        Returns:
            Returns a list of all parent types
    """
    types = []
    parent = self
    while parent:
        types.append(parent.rest_name)
        parent = parent.parent_object
    return types

def genealogy_contains_id(self, id):
    """ Check if parents contains an object of type resource_name
        Args:
            id: the id of the resource to find
        Returns:
            Returns True if a parent with specific id has been found. False otherwise.
    """
    ids = self.genealogic_ids()
    return id in ids

def genealogy_contains_type(self, resource_name):
    """ Check if parents contains an object of type resource_name
        Args:
            resource_name: the name of the resource to find
        Returns:
            Returns True if a parent of type has been found. False otherwise.
    """
    resource_names = self.genealogic_types()
    return resource_name in resource_names

def get_attribute_infos(self, local_name):
    """ Get exposed attribute information
        Args:
            local_name: the attribute name
        Returns:
            A dictionary of all information
    """
    if local_name in self._attributes:
        return self._attributes[local_name]
    return None

def get_attributes(self):
    """ Get all attributes information
        Returns:
            Returns a dictionnary containing attribute information
    """
    return self._attributes.values()

def get_formated_creation_date(self, format='%b %Y %d %H:%I:%S'):
    """ Return creation date with a given format. Default is '%b %Y %d %H:%I:%S' """
    if not self._creation_date:
        return None
    date = datetime.datetime.utcfromtimestamp(self._creation_date)
    return date.strftime(format)

def get_resource_url(self):
    """ Get resource complete url """
    name = self.__class__.resource_name
    url = self.__class__.rest_base_url()
    if self.id is not None:
        return "%s/%s/%s" % (url, name, self.id)
    return "%s/%s" % (url, name)

def get_resource_url_for_child_type(self, nurest_object_type):
    """ Get the resource url for the nurest_object type """
    return "%s/%s" % (self.get_resource_url(), nurest_object_type.resource_name)

def instantiate_child(self, nurest_object, from_template, response_choice=None, async=False, callback=None, commit=True):
    """ Instantiate an nurest_object from a template object
        Args:
            nurest_object: the NURESTObject object to add
            from_template: the NURESTObject template object
            callback: callback containing the object and the connection
        Returns:
            Returns the object and connection (object, connection)
        Example:
            >>> parent_entity = NUParentEntity(id="xxxx-xxxx-xxx-xxxx") # create a NUParentEntity with an existing ID (or retrieve one)
            >>> other_entity_template = NUOtherEntityTemplate(id="yyyy-yyyy-yyyy-yyyy") # create a NUOtherEntityTemplate with an existing ID (or retrieve one)
            >>> other_entity_instance = NUOtherEntityInstance(name="my new instance") # create a new NUOtherEntityInstance to be intantiated from other_entity_template
            >>>
            >>> parent_entity.instantiate_child(other_entity_instance, other_entity_template) # instatiate the new domain in the server
    """
    # if nurest_object.id:
    #     raise InternalConsitencyError("Cannot instantiate a child that already has an ID: %s." % nurest_object)
    if not from_template.id:
        raise InternalConsitencyError("Cannot instantiate a child from a template with no ID: %s." % from_template)
    nurest_object.template_id = from_template.id
    return self._manage_child_object(nurest_object=nurest_object,
                                     async=async,
                                     method=HTTP_METHOD_POST,
                                     callback=callback,
                                     handler=self._did_create_child,
                                     response_choice=response_choice,
                                     commit=commit)

def is_owned_by_current_user(self):
    """ Check if the current user owns the object """
    from bambou.nurest_root_object import NURESTRootObject
    root_object = NURESTRootObject.get_default_root_object()
    return self._owner == root_object.id

def is_valid(self):
    """
    """
    return len(self.errors) == 0

@classmethod
def object_with_id(cls, id):
    """ Get a new object with the given id
        Returns:
            Returns a new instance with specified id
    """
    new_object = cls()
    new_object.id = id
    return new_object

def parent_for_matching_rest_name(self, rest_names):
    """ Return parent that matches a rest name """
    parent = self
    while parent:
        if parent.rest_name in rest_names:
            return parent
        parent = parent.parent_object
    return None

def register_fetcher(self, fetcher, rest_name):
    """ Register a children fetcher
    """
    self._fetchers_registry[rest_name] = fetcher

def remove_child(self, child):
    """ Remove a child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    target_child = None
    for local_child in children:
        if local_child.id == child.id:
            target_child = local_child
            break
    if target_child:
        target_child.parent_object = None
        children.remove(target_child)

@classmethod
def rest_base_url(cls):
    """ Override this method to set object base url """
    controller = _NURESTSessionCurrentContext.session.login_controller
    return controller.url

def rest_equals(self, rest_object):
    """ Compare objects REST attributes
    """
    if not self.equals(rest_object):
        return False
    return self.to_dict() == rest_object.to_dict()

def save(self, response_choice=None, async=False, callback=None):
    """ Update object and call given callback in case of async call
        Args:
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Example:
            >>> entity.name = "My Super Object"
            >>> entity.save() # will save the new name in the server
    """
    return self._manage_child_object(nurest_object=self, method=HTTP_METHOD_PUT, async=async, callback=callback, response_choice=response_choice)

def send_request(self, request, async=False, local_callback=None, remote_callback=None, user_info=None):
    """ Sends a request, calls the local callback, then the remote callback in case of async call
        Args:
            request: The request to send
            local_callback: local method that will be triggered in case of async call
            remote_callback: remote moethd that will be triggered in case of async call
            user_info: contains additionnal information to carry during the request
        Returns:
            Returns the object and connection (object, connection)
    """
    callbacks = dict()
    if local_callback:
        callbacks['local'] = local_callback
    if remote_callback:
        callbacks['remote'] = remote_callback
    connection = NURESTConnection(request=request, async=async, callback=self._did_receive_response, callbacks=callbacks)
    connection.user_info = user_info
    return connection.start()

def to_dict(self):
    """ Converts the current object into a Dictionary using all exposed ReST attributes.
        Returns:
            dict: the dictionary containing all the exposed ReST attributes and their values.
        Example::
            >>> print entity.to_dict()
            {"name": "my entity", "description": "Hello World", "ID": "xxxx-xxx-xxxx-xxx", ...}
    """
    dictionary = dict()
    for local_name, attribute in self._attributes.iteritems():
        remote_name = attribute.remote_name
        if hasattr(self, local_name):
            value = getattr(self, local_name)
            # Removed to resolve issue http://mvjira.mv.usa.alcatel.com/browse/VSD-5940 (12/15/2014)
            # if isinstance(value, bool):
            #     value = int(value)
            if isinstance(value, NURESTObject):
                value = value.to_dict()
            if isinstance(value, list) and len(value) > 0 and isinstance(value[0], NURESTObject):
                tmp = list()
                for obj in value:
                    tmp.append(obj.to_dict())
                value = tmp
            dictionary[remote_name] = value
        else:
            pass  # pragma: no cover
    return dictionary

def update_child(self, child):
    """ Update child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    index = None
    for local_child in children:
        if local_child.id == child.id:
            index = children.index(local_child)
            break
    if index is not None:
        children[index] = child

def validate(self):
    """ Validate the current object attributes.
        Check all attributes and store errors
        Returns:
            Returns True if all attibutes of the object
            respect contraints. Returns False otherwise and
            store error in errors dict.
    """
    self._attribute_errors = dict()  # Reset validation errors
    for local_name, attribute in self._attributes.iteritems():
        value = getattr(self, local_name, None)
        if attribute.is_required and (value is None or value == ""):
            self._attribute_errors[local_name] = {'title': 'Invalid input',
                                                  'description': 'This value is mandatory.',
                                                  'remote_name': attribute.remote_name}
            continue
        if value is None:
            continue  # without error
        if type(value) != attribute.attribute_type:
            if attribute.attribute_type != str or type(value) != unicode:
                self._attribute_errors[local_name] = {'title': 'Wrong type',
                                                      'description': 'Attribute %s type should be %s but is %s' % (attribute.remote_name, attribute.attribute_type, type(value)),
                                                      'remote_name': attribute.remote_name}
                continue
        if attribute.min_length and len(value) < attribute.min_length:
            self._attribute_errors[local_name] = {'title': 'Invalid lenght',
                                                  'description': 'Attribute %s minimum size should be %s but is %s' % (attribute.remote_name, attribute.min_length, len(value)),
                                                  'remote_name': attribute.remote_name}
            continue
        if attribute.max_length and len(value) > attribute.max_length:
            self._attribute_errors[local_name] = {'title': 'Invalid lenght',
                                                  'description': 'Attribute %s maximum size should be %s but is %s' % (attribute.remote_name, attribute.max_length, len(value)),
                                                  'remote_name': attribute.remote_name}
            continue
        if attribute.choices and value not in attribute.choices:
            self._attribute_errors[local_name] = {'title': 'Invalid input',
                                                  'description': 'Invalid input',
                                                  'remote_name': attribute.remote_name}
            continue
    return self.is_valid()

def __init__(self, **kwargs):
    """ Initializes a AggregateMetadata instance
        Notes:
            You can specify all parameters while calling this methods.
            A special argument named `data` will enable you to load the
            object from a Python dictionary
        Examples:
            >>> aggregatemetadata = NUAggregateMetadata(id=u'xxxx-xxx-xxx-xxx', name=u'AggregateMetadata')
            >>> aggregatemetadata = NUAggregateMetadata(data=my_dict)
    """
    super(NUAggregateMetadata, self).__init__()
    # Read/Write Attributes
    
    self._name = None
    self._description = None
    self._metadata_tag_ids = None
    self._network_notification_disabled = None
    self._blob = None
    self._global_metadata = None
    self._entity_scope = None
    self._external_id = None
    
    self.expose_attribute(local_name="name", remote_name="name", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="description", remote_name="description", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="metadata_tag_ids", remote_name="metadataTagIDs", attribute_type=list, is_required=False, is_unique=False)
    self.expose_attribute(local_name="network_notification_disabled", remote_name="networkNotificationDisabled", attribute_type=bool, is_required=False, is_unique=False)
    self.expose_attribute(local_name="blob", remote_name="blob", attribute_type=str, is_required=True, is_unique=False)
    self.expose_attribute(local_name="global_metadata", remote_name="global", attribute_type=bool, is_required=False, is_unique=False)
    self.expose_attribute(local_name="entity_scope", remote_name="entityScope", attribute_type=str, is_required=False, is_unique=False, choices=[u'ENTERPRISE', u'GLOBAL'])
    self.expose_attribute(local_name="external_id", remote_name="externalID", attribute_type=str, is_required=False, is_unique=True)
    
    self._compute_args(**kwargs)

def add_child(self, child):
    """ Add a child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    if children is None:
        raise InternalConsitencyError('Could not find fetcher with name %s while adding %s in parent %s' % (rest_name, child, self))
    if child not in children:
        child.parent_object = self
        children.append(child)

def assign(self, objects, nurest_object_type, async=False, callback=None, commit=True):
    """ Reference a list of objects into the current resource
        Args:
            objects (list): list of NURESTObject to link
            nurest_object_type (type): Type of the object to link
            callback (function): Callback method that should be fired at the end
        Returns:
            Returns the current object and the connection (object, connection)
        Example:
            >>> entity.assign([entity1, entity2, entity3], NUEntity) # entity1, entity2 and entity3 are now part of the entity
    """
    ids = list()
    for nurest_object in objects:
        ids.append(nurest_object.id)
    url = self.get_resource_url_for_child_type(nurest_object_type)
    request = NURESTRequest(method=HTTP_METHOD_PUT, url=url, data=ids)
    user_info = {'nurest_objects': objects, 'commit': commit}
    if async:
        return self.send_request(request=request,
                                 async=async,
                                 local_callback=self._did_perform_standard_operation,
                                 remote_callback=callback,
                                 user_info=user_info)
    else:
        connection = self.send_request(request=request,
                                       user_info=user_info)
        return self._did_perform_standard_operation(connection)

def copy(self):
    """ Returns a copy of the current object
        Returns:
            A copy of the given object
        Example::
            >>> print entity.to_dict()
            
    """
    return self.__class__(data=self.to_dict())

def create_child(self, nurest_object, response_choice=None, async=False, callback=None, commit=True):
    """ Add given nurest_object to the current object
        For example, to add a child into a parent, you can call
        parent.create_child(nurest_object=child)
        Args:
            nurest_object (bambou.NURESTObject): the NURESTObject object to add
            response_choice (int): Automatically send a response choice when confirmation is needed
            async (bool): should the request be done asynchronously or not
            callback (function): callback containing the object and the connection
        Returns:
            Returns the object and connection (object, connection)
        Example:
            >>> entity = NUEntity(name="Super Entity")
            >>> parent_entity.create_child(entity) # the new entity as been created in the parent_entity
    """
    # if nurest_object.id:
    #     raise InternalConsitencyError("Cannot create a child that already has an ID: %s." % nurest_object)
    return self._manage_child_object(nurest_object=nurest_object,
                                     async=async,
                                     method=HTTP_METHOD_POST,
                                     callback=callback,
                                     handler=self._did_create_child,
                                     response_choice=response_choice,
                                     commit=commit)

def delete(self, response_choice=1, async=False, callback=None):
    """ Delete object and call given callback in case of call.
        Args:
            response_choice (int): Automatically send a response choice when confirmation is needed
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Example:
            >>> entity.delete() # will delete the enterprise from the server
    """
    return self._manage_child_object(nurest_object=self, method=HTTP_METHOD_DELETE, async=async, callback=callback, response_choice=response_choice)

def equals(self, rest_object):
    """ Compare with another object """
    if self._is_dirty:
        return False
    if rest_object is None:
        return False
    if not isinstance(rest_object, NURESTObject):
        raise TypeError('The object is not a NURESTObject %s' % rest_object)
    if self.rest_name != rest_object.rest_name:
        return False
    if self.id and rest_object.id:
        return self.id == rest_object.id
    if self.local_id and rest_object.local_id:
        return self.local_id == rest_object.local_id
    return False

def expose_attribute(self, local_name, attribute_type, remote_name=None, display_name=None, is_required=False, is_readonly=False, max_length=None, min_length=None, is_identifier=False, choices=None, is_unique=False, is_email=False, is_login=False, is_editable=True, is_password=False, can_order=False, can_search=False):
    """ Expose local_name as remote_name
        An exposed attribute `local_name` will be sent within the HTTP request as
        a `remote_name`
    """
    if remote_name is None:
        remote_name = local_name
    if display_name is None:
        display_name = local_name
    attribute = NURemoteAttribute(local_name=local_name, remote_name=remote_name, attribute_type=attribute_type)
    attribute.display_name = display_name
    attribute.is_required = is_required
    attribute.is_readonly = is_readonly
    attribute.min_length = min_length
    attribute.max_length = max_length
    attribute.is_editable = is_editable
    attribute.is_identifier = is_identifier
    attribute.choices = choices
    attribute.is_unique = is_unique
    attribute.is_email = is_email
    attribute.is_login = is_login
    attribute.is_password = is_password
    attribute.can_order = can_order
    attribute.can_search = can_search
    self._attributes[local_name] = attribute

def fetch(self, async=False, callback=None):
    """ Fetch all information about the current object
        Args:
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Returns:
            tuple: (current_fetcher, callee_parent, fetched_bjects, connection)
        Example:
            >>> entity = NUEntity(id="xxx-xxx-xxx-xxx")
            >>> entity.fetch() # will get the entity with id "xxx-xxx-xxx-xxx"
            >>> print entity.name
            "My Entity"
    """
    if self.id is None:
        raise InternalConsitencyError("Cannot fetch an object that does not have an ID")
    request = NURESTRequest(method=HTTP_METHOD_GET, url=self.get_resource_url())
    if async:
        return self.send_request(request=request, async=async, local_callback=self._did_retrieve, remote_callback=callback)
    else:
        connection = self.send_request(request=request)
        return self._did_retrieve(connection)

def fetcher_for_rest_name(self, rest_name):
    """ Returns the children fetcher for the given rest name
        Args:
            rest_name (string): the children rest name
        Returns:
            list: Returns the corresponding fetcher
        Example:
            >>> print entity.fetcher_for_rest_name(NUSubEntity.rest_name)
            
    """
    if rest_name not in self._fetchers_registry:
        return None
    return self._fetchers_registry[rest_name]

def from_dict(self, dictionary):
    """ Sets all the exposed ReST attribues from the given dictionary
        Args:
            dictionary (dict): dictionnary containing the raw object attributes and their values.
        Example:
            >>> info = {"name": "my group", "private": False}
            >>> group = NUGroup()
            >>> group.from_dict(info)
            >>> print "name: %s - private: %s" % (group.name, group.private)
            "name: my group - private: False"
    """
    for remote_name, remote_value in dictionary.iteritems():
        # Check if a local attribute is exposed with the remote_name
        # if no attribute is exposed, return None
        local_name = next((name for name, attribute in self._attributes.iteritems() if attribute.remote_name == remote_name), None)
        if local_name:
            setattr(self, local_name, remote_value)
        else:
            # print('Attribute %s could not be added to object %s' % (remote_name, self))
            pass  # pragma: no cover

def genealogic_ids(self):
    """ Get all genealogic ids
        Returns:
             A list of all parent ids
    """
    ids = []
    parent = self
    while parent:
        ids.append(parent.id)
        parent = parent.parent_object
    return ids

def genealogic_types(self):
    """ Get genealogic types
        Returns:
            Returns a list of all parent types
    """
    types = []
    parent = self
    while parent:
        types.append(parent.rest_name)
        parent = parent.parent_object
    return types

def genealogy_contains_id(self, id):
    """ Check if parents contains an object of type resource_name
        Args:
            id: the id of the resource to find
        Returns:
            Returns True if a parent with specific id has been found. False otherwise.
    """
    ids = self.genealogic_ids()
    return id in ids

def genealogy_contains_type(self, resource_name):
    """ Check if parents contains an object of type resource_name
        Args:
            resource_name: the name of the resource to find
        Returns:
            Returns True if a parent of type has been found. False otherwise.
    """
    resource_names = self.genealogic_types()
    return resource_name in resource_names

def get_attribute_infos(self, local_name):
    """ Get exposed attribute information
        Args:
            local_name: the attribute name
        Returns:
            A dictionary of all information
    """
    if local_name in self._attributes:
        return self._attributes[local_name]
    return None

def get_attributes(self):
    """ Get all attributes information
        Returns:
            Returns a dictionnary containing attribute information
    """
    return self._attributes.values()

def get_formated_creation_date(self, format='%b %Y %d %H:%I:%S'):
    """ Return creation date with a given format. Default is '%b %Y %d %H:%I:%S' """
    if not self._creation_date:
        return None
    date = datetime.datetime.utcfromtimestamp(self._creation_date)
    return date.strftime(format)

def get_resource_url(self):
    """ Get resource complete url """
    name = self.__class__.resource_name
    url = self.__class__.rest_base_url()
    if self.id is not None:
        return "%s/%s/%s" % (url, name, self.id)
    return "%s/%s" % (url, name)

def get_resource_url_for_child_type(self, nurest_object_type):
    """ Get the resource url for the nurest_object type """
    return "%s/%s" % (self.get_resource_url(), nurest_object_type.resource_name)

def instantiate_child(self, nurest_object, from_template, response_choice=None, async=False, callback=None, commit=True):
    """ Instantiate an nurest_object from a template object
        Args:
            nurest_object: the NURESTObject object to add
            from_template: the NURESTObject template object
            callback: callback containing the object and the connection
        Returns:
            Returns the object and connection (object, connection)
        Example:
            >>> parent_entity = NUParentEntity(id="xxxx-xxxx-xxx-xxxx") # create a NUParentEntity with an existing ID (or retrieve one)
            >>> other_entity_template = NUOtherEntityTemplate(id="yyyy-yyyy-yyyy-yyyy") # create a NUOtherEntityTemplate with an existing ID (or retrieve one)
            >>> other_entity_instance = NUOtherEntityInstance(name="my new instance") # create a new NUOtherEntityInstance to be intantiated from other_entity_template
            >>>
            >>> parent_entity.instantiate_child(other_entity_instance, other_entity_template) # instatiate the new domain in the server
    """
    # if nurest_object.id:
    #     raise InternalConsitencyError("Cannot instantiate a child that already has an ID: %s." % nurest_object)
    if not from_template.id:
        raise InternalConsitencyError("Cannot instantiate a child from a template with no ID: %s." % from_template)
    nurest_object.template_id = from_template.id
    return self._manage_child_object(nurest_object=nurest_object,
                                     async=async,
                                     method=HTTP_METHOD_POST,
                                     callback=callback,
                                     handler=self._did_create_child,
                                     response_choice=response_choice,
                                     commit=commit)

def is_owned_by_current_user(self):
    """ Check if the current user owns the object """
    from bambou.nurest_root_object import NURESTRootObject
    root_object = NURESTRootObject.get_default_root_object()
    return self._owner == root_object.id

def is_valid(self):
    """
    """
    return len(self.errors) == 0

@classmethod
def object_with_id(cls, id):
    """ Get a new object with the given id
        Returns:
            Returns a new instance with specified id
    """
    new_object = cls()
    new_object.id = id
    return new_object

def parent_for_matching_rest_name(self, rest_names):
    """ Return parent that matches a rest name """
    parent = self
    while parent:
        if parent.rest_name in rest_names:
            return parent
        parent = parent.parent_object
    return None

def register_fetcher(self, fetcher, rest_name):
    """ Register a children fetcher
    """
    self._fetchers_registry[rest_name] = fetcher

def remove_child(self, child):
    """ Remove a child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    target_child = None
    for local_child in children:
        if local_child.id == child.id:
            target_child = local_child
            break
    if target_child:
        target_child.parent_object = None
        children.remove(target_child)

@classmethod
def rest_base_url(cls):
    """ Override this method to set object base url """
    controller = _NURESTSessionCurrentContext.session.login_controller
    return controller.url

def rest_equals(self, rest_object):
    """ Compare objects REST attributes
    """
    if not self.equals(rest_object):
        return False
    return self.to_dict() == rest_object.to_dict()

def save(self, response_choice=None, async=False, callback=None):
    """ Update object and call given callback in case of async call
        Args:
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Example:
            >>> entity.name = "My Super Object"
            >>> entity.save() # will save the new name in the server
    """
    return self._manage_child_object(nurest_object=self, method=HTTP_METHOD_PUT, async=async, callback=callback, response_choice=response_choice)

def send_request(self, request, async=False, local_callback=None, remote_callback=None, user_info=None):
    """ Sends a request, calls the local callback, then the remote callback in case of async call
        Args:
            request: The request to send
            local_callback: local method that will be triggered in case of async call
            remote_callback: remote moethd that will be triggered in case of async call
            user_info: contains additionnal information to carry during the request
        Returns:
            Returns the object and connection (object, connection)
    """
    callbacks = dict()
    if local_callback:
        callbacks['local'] = local_callback
    if remote_callback:
        callbacks['remote'] = remote_callback
    connection = NURESTConnection(request=request, async=async, callback=self._did_receive_response, callbacks=callbacks)
    connection.user_info = user_info
    return connection.start()

def to_dict(self):
    """ Converts the current object into a Dictionary using all exposed ReST attributes.
        Returns:
            dict: the dictionary containing all the exposed ReST attributes and their values.
        Example::
            >>> print entity.to_dict()
            {"name": "my entity", "description": "Hello World", "ID": "xxxx-xxx-xxxx-xxx", ...}
    """
    dictionary = dict()
    for local_name, attribute in self._attributes.iteritems():
        remote_name = attribute.remote_name
        if hasattr(self, local_name):
            value = getattr(self, local_name)
            # Removed to resolve issue http://mvjira.mv.usa.alcatel.com/browse/VSD-5940 (12/15/2014)
            # if isinstance(value, bool):
            #     value = int(value)
            if isinstance(value, NURESTObject):
                value = value.to_dict()
            if isinstance(value, list) and len(value) > 0 and isinstance(value[0], NURESTObject):
                tmp = list()
                for obj in value:
                    tmp.append(obj.to_dict())
                value = tmp
            dictionary[remote_name] = value
        else:
            pass  # pragma: no cover
    return dictionary

def update_child(self, child):
    """ Update child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    index = None
    for local_child in children:
        if local_child.id == child.id:
            index = children.index(local_child)
            break
    if index is not None:
        children[index] = child

def validate(self):
    """ Validate the current object attributes.
        Check all attributes and store errors
        Returns:
            Returns True if all attibutes of the object
            respect contraints. Returns False otherwise and
            store error in errors dict.
    """
    self._attribute_errors = dict()  # Reset validation errors
    for local_name, attribute in self._attributes.iteritems():
        value = getattr(self, local_name, None)
        if attribute.is_required and (value is None or value == ""):
            self._attribute_errors[local_name] = {'title': 'Invalid input',
                                                  'description': 'This value is mandatory.',
                                                  'remote_name': attribute.remote_name}
            continue
        if value is None:
            continue  # without error
        if type(value) != attribute.attribute_type:
            if attribute.attribute_type != str or type(value) != unicode:
                self._attribute_errors[local_name] = {'title': 'Wrong type',
                                                      'description': 'Attribute %s type should be %s but is %s' % (attribute.remote_name, attribute.attribute_type, type(value)),
                                                      'remote_name': attribute.remote_name}
                continue
        if attribute.min_length and len(value) < attribute.min_length:
            self._attribute_errors[local_name] = {'title': 'Invalid lenght',
                                                  'description': 'Attribute %s minimum size should be %s but is %s' % (attribute.remote_name, attribute.min_length, len(value)),
                                                  'remote_name': attribute.remote_name}
            continue
        if attribute.max_length and len(value) > attribute.max_length:
            self._attribute_errors[local_name] = {'title': 'Invalid lenght',
                                                  'description': 'Attribute %s maximum size should be %s but is %s' % (attribute.remote_name, attribute.max_length, len(value)),
                                                  'remote_name': attribute.remote_name}
            continue
        if attribute.choices and value not in attribute.choices:
            self._attribute_errors[local_name] = {'title': 'Invalid input',
                                                  'description': 'Invalid input',
                                                  'remote_name': attribute.remote_name}
            continue
    return self.is_valid()

def __init__(self, **kwargs):
    """ Initializes a Alarm instance
        Notes:
            You can specify all parameters while calling this methods.
            A special argument named `data` will enable you to load the
            object from a Python dictionary
        Examples:
            >>> alarm = NUAlarm(id=u'xxxx-xxx-xxx-xxx', name=u'Alarm')
            >>> alarm = NUAlarm(data=my_dict)
    """
    super(NUAlarm, self).__init__()
    # Read/Write Attributes
    
    self._name = None
    self._target_object = None
    self._last_updated_by = None
    self._acknowledged = None
    self._reason = None
    self._description = None
    self._severity = None
    self._timestamp = None
    self._enterprise_id = None
    self._entity_scope = None
    self._error_condition = None
    self._number_of_occurances = None
    self._external_id = None
    
    self.expose_attribute(local_name="name", remote_name="name", attribute_type=str, is_required=True, is_unique=False)
    self.expose_attribute(local_name="target_object", remote_name="targetObject", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="last_updated_by", remote_name="lastUpdatedBy", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="acknowledged", remote_name="acknowledged", attribute_type=bool, is_required=False, is_unique=False)
    self.expose_attribute(local_name="reason", remote_name="reason", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="description", remote_name="description", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="severity", remote_name="severity", attribute_type=str, is_required=False, is_unique=False, choices=[u'CRITICAL', u'INFO', u'MAJOR', u'MINOR', u'WARNING'])
    self.expose_attribute(local_name="timestamp", remote_name="timestamp", attribute_type=int, is_required=False, is_unique=False)
    self.expose_attribute(local_name="enterprise_id", remote_name="enterpriseID", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="entity_scope", remote_name="entityScope", attribute_type=str, is_required=False, is_unique=False, choices=[u'ENTERPRISE', u'GLOBAL'])
    self.expose_attribute(local_name="error_condition", remote_name="errorCondition", attribute_type=int, is_required=False, is_unique=False)
    self.expose_attribute(local_name="number_of_occurances", remote_name="numberOfOccurances", attribute_type=int, is_required=False, is_unique=False)
    self.expose_attribute(local_name="external_id", remote_name="externalID", attribute_type=str, is_required=False, is_unique=True)
    
    # Fetchers
    
    
    self.metadatas = NUMetadatasFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.global_metadatas = NUGlobalMetadatasFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    self._compute_args(**kwargs)

def add_child(self, child):
    """ Add a child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    if children is None:
        raise InternalConsitencyError('Could not find fetcher with name %s while adding %s in parent %s' % (rest_name, child, self))
    if child not in children:
        child.parent_object = self
        children.append(child)

def assign(self, objects, nurest_object_type, async=False, callback=None, commit=True):
    """ Reference a list of objects into the current resource
        Args:
            objects (list): list of NURESTObject to link
            nurest_object_type (type): Type of the object to link
            callback (function): Callback method that should be fired at the end
        Returns:
            Returns the current object and the connection (object, connection)
        Example:
            >>> entity.assign([entity1, entity2, entity3], NUEntity) # entity1, entity2 and entity3 are now part of the entity
    """
    ids = list()
    for nurest_object in objects:
        ids.append(nurest_object.id)
    url = self.get_resource_url_for_child_type(nurest_object_type)
    request = NURESTRequest(method=HTTP_METHOD_PUT, url=url, data=ids)
    user_info = {'nurest_objects': objects, 'commit': commit}
    if async:
        return self.send_request(request=request,
                                 async=async,
                                 local_callback=self._did_perform_standard_operation,
                                 remote_callback=callback,
                                 user_info=user_info)
    else:
        connection = self.send_request(request=request,
                                       user_info=user_info)
        return self._did_perform_standard_operation(connection)

def copy(self):
    """ Returns a copy of the current object
        Returns:
            A copy of the given object
        Example::
            >>> print entity.to_dict()
            
    """
    return self.__class__(data=self.to_dict())

def create_child(self, nurest_object, response_choice=None, async=False, callback=None, commit=True):
    """ Add given nurest_object to the current object
        For example, to add a child into a parent, you can call
        parent.create_child(nurest_object=child)
        Args:
            nurest_object (bambou.NURESTObject): the NURESTObject object to add
            response_choice (int): Automatically send a response choice when confirmation is needed
            async (bool): should the request be done asynchronously or not
            callback (function): callback containing the object and the connection
        Returns:
            Returns the object and connection (object, connection)
        Example:
            >>> entity = NUEntity(name="Super Entity")
            >>> parent_entity.create_child(entity) # the new entity as been created in the parent_entity
    """
    # if nurest_object.id:
    #     raise InternalConsitencyError("Cannot create a child that already has an ID: %s." % nurest_object)
    return self._manage_child_object(nurest_object=nurest_object,
                                     async=async,
                                     method=HTTP_METHOD_POST,
                                     callback=callback,
                                     handler=self._did_create_child,
                                     response_choice=response_choice,
                                     commit=commit)

def delete(self, response_choice=1, async=False, callback=None):
    """ Delete object and call given callback in case of call.
        Args:
            response_choice (int): Automatically send a response choice when confirmation is needed
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Example:
            >>> entity.delete() # will delete the enterprise from the server
    """
    return self._manage_child_object(nurest_object=self, method=HTTP_METHOD_DELETE, async=async, callback=callback, response_choice=response_choice)

def equals(self, rest_object):
    """ Compare with another object """
    if self._is_dirty:
        return False
    if rest_object is None:
        return False
    if not isinstance(rest_object, NURESTObject):
        raise TypeError('The object is not a NURESTObject %s' % rest_object)
    if self.rest_name != rest_object.rest_name:
        return False
    if self.id and rest_object.id:
        return self.id == rest_object.id
    if self.local_id and rest_object.local_id:
        return self.local_id == rest_object.local_id
    return False

def expose_attribute(self, local_name, attribute_type, remote_name=None, display_name=None, is_required=False, is_readonly=False, max_length=None, min_length=None, is_identifier=False, choices=None, is_unique=False, is_email=False, is_login=False, is_editable=True, is_password=False, can_order=False, can_search=False):
    """ Expose local_name as remote_name
        An exposed attribute `local_name` will be sent within the HTTP request as
        a `remote_name`
    """
    if remote_name is None:
        remote_name = local_name
    if display_name is None:
        display_name = local_name
    attribute = NURemoteAttribute(local_name=local_name, remote_name=remote_name, attribute_type=attribute_type)
    attribute.display_name = display_name
    attribute.is_required = is_required
    attribute.is_readonly = is_readonly
    attribute.min_length = min_length
    attribute.max_length = max_length
    attribute.is_editable = is_editable
    attribute.is_identifier = is_identifier
    attribute.choices = choices
    attribute.is_unique = is_unique
    attribute.is_email = is_email
    attribute.is_login = is_login
    attribute.is_password = is_password
    attribute.can_order = can_order
    attribute.can_search = can_search
    self._attributes[local_name] = attribute

def fetch(self, async=False, callback=None):
    """ Fetch all information about the current object
        Args:
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Returns:
            tuple: (current_fetcher, callee_parent, fetched_bjects, connection)
        Example:
            >>> entity = NUEntity(id="xxx-xxx-xxx-xxx")
            >>> entity.fetch() # will get the entity with id "xxx-xxx-xxx-xxx"
            >>> print entity.name
            "My Entity"
    """
    if self.id is None:
        raise InternalConsitencyError("Cannot fetch an object that does not have an ID")
    request = NURESTRequest(method=HTTP_METHOD_GET, url=self.get_resource_url())
    if async:
        return self.send_request(request=request, async=async, local_callback=self._did_retrieve, remote_callback=callback)
    else:
        connection = self.send_request(request=request)
        return self._did_retrieve(connection)

def fetcher_for_rest_name(self, rest_name):
    """ Returns the children fetcher for the given rest name
        Args:
            rest_name (string): the children rest name
        Returns:
            list: Returns the corresponding fetcher
        Example:
            >>> print entity.fetcher_for_rest_name(NUSubEntity.rest_name)
            
    """
    if rest_name not in self._fetchers_registry:
        return None
    return self._fetchers_registry[rest_name]

def from_dict(self, dictionary):
    """ Sets all the exposed ReST attribues from the given dictionary
        Args:
            dictionary (dict): dictionnary containing the raw object attributes and their values.
        Example:
            >>> info = {"name": "my group", "private": False}
            >>> group = NUGroup()
            >>> group.from_dict(info)
            >>> print "name: %s - private: %s" % (group.name, group.private)
            "name: my group - private: False"
    """
    for remote_name, remote_value in dictionary.iteritems():
        # Check if a local attribute is exposed with the remote_name
        # if no attribute is exposed, return None
        local_name = next((name for name, attribute in self._attributes.iteritems() if attribute.remote_name == remote_name), None)
        if local_name:
            setattr(self, local_name, remote_value)
        else:
            # print('Attribute %s could not be added to object %s' % (remote_name, self))
            pass  # pragma: no cover

def genealogic_ids(self):
    """ Get all genealogic ids
        Returns:
             A list of all parent ids
    """
    ids = []
    parent = self
    while parent:
        ids.append(parent.id)
        parent = parent.parent_object
    return ids

def genealogic_types(self):
    """ Get genealogic types
        Returns:
            Returns a list of all parent types
    """
    types = []
    parent = self
    while parent:
        types.append(parent.rest_name)
        parent = parent.parent_object
    return types

def genealogy_contains_id(self, id):
    """ Check if parents contains an object of type resource_name
        Args:
            id: the id of the resource to find
        Returns:
            Returns True if a parent with specific id has been found. False otherwise.
    """
    ids = self.genealogic_ids()
    return id in ids

def genealogy_contains_type(self, resource_name):
    """ Check if parents contains an object of type resource_name
        Args:
            resource_name: the name of the resource to find
        Returns:
            Returns True if a parent of type has been found. False otherwise.
    """
    resource_names = self.genealogic_types()
    return resource_name in resource_names

def get_attribute_infos(self, local_name):
    """ Get exposed attribute information
        Args:
            local_name: the attribute name
        Returns:
            A dictionary of all information
    """
    if local_name in self._attributes:
        return self._attributes[local_name]
    return None

def get_attributes(self):
    """ Get all attributes information
        Returns:
            Returns a dictionnary containing attribute information
    """
    return self._attributes.values()

def get_formated_creation_date(self, format='%b %Y %d %H:%I:%S'):
    """ Return creation date with a given format. Default is '%b %Y %d %H:%I:%S' """
    if not self._creation_date:
        return None
    date = datetime.datetime.utcfromtimestamp(self._creation_date)
    return date.strftime(format)

def get_resource_url(self):
    """ Get resource complete url """
    name = self.__class__.resource_name
    url = self.__class__.rest_base_url()
    if self.id is not None:
        return "%s/%s/%s" % (url, name, self.id)
    return "%s/%s" % (url, name)

def get_resource_url_for_child_type(self, nurest_object_type):
    """ Get the resource url for the nurest_object type """
    return "%s/%s" % (self.get_resource_url(), nurest_object_type.resource_name)

def instantiate_child(self, nurest_object, from_template, response_choice=None, async=False, callback=None, commit=True):
    """ Instantiate an nurest_object from a template object
        Args:
            nurest_object: the NURESTObject object to add
            from_template: the NURESTObject template object
            callback: callback containing the object and the connection
        Returns:
            Returns the object and connection (object, connection)
        Example:
            >>> parent_entity = NUParentEntity(id="xxxx-xxxx-xxx-xxxx") # create a NUParentEntity with an existing ID (or retrieve one)
            >>> other_entity_template = NUOtherEntityTemplate(id="yyyy-yyyy-yyyy-yyyy") # create a NUOtherEntityTemplate with an existing ID (or retrieve one)
            >>> other_entity_instance = NUOtherEntityInstance(name="my new instance") # create a new NUOtherEntityInstance to be intantiated from other_entity_template
            >>>
            >>> parent_entity.instantiate_child(other_entity_instance, other_entity_template) # instatiate the new domain in the server
    """
    # if nurest_object.id:
    #     raise InternalConsitencyError("Cannot instantiate a child that already has an ID: %s." % nurest_object)
    if not from_template.id:
        raise InternalConsitencyError("Cannot instantiate a child from a template with no ID: %s." % from_template)
    nurest_object.template_id = from_template.id
    return self._manage_child_object(nurest_object=nurest_object,
                                     async=async,
                                     method=HTTP_METHOD_POST,
                                     callback=callback,
                                     handler=self._did_create_child,
                                     response_choice=response_choice,
                                     commit=commit)

def is_owned_by_current_user(self):
    """ Check if the current user owns the object """
    from bambou.nurest_root_object import NURESTRootObject
    root_object = NURESTRootObject.get_default_root_object()
    return self._owner == root_object.id

def is_valid(self):
    """
    """
    return len(self.errors) == 0

@classmethod
def object_with_id(cls, id):
    """ Get a new object with the given id
        Returns:
            Returns a new instance with specified id
    """
    new_object = cls()
    new_object.id = id
    return new_object

def parent_for_matching_rest_name(self, rest_names):
    """ Return parent that matches a rest name """
    parent = self
    while parent:
        if parent.rest_name in rest_names:
            return parent
        parent = parent.parent_object
    return None

def register_fetcher(self, fetcher, rest_name):
    """ Register a children fetcher
    """
    self._fetchers_registry[rest_name] = fetcher

def remove_child(self, child):
    """ Remove a child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    target_child = None
    for local_child in children:
        if local_child.id == child.id:
            target_child = local_child
            break
    if target_child:
        target_child.parent_object = None
        children.remove(target_child)

@classmethod
def rest_base_url(cls):
    """ Override this method to set object base url """
    controller = _NURESTSessionCurrentContext.session.login_controller
    return controller.url

def rest_equals(self, rest_object):
    """ Compare objects REST attributes
    """
    if not self.equals(rest_object):
        return False
    return self.to_dict() == rest_object.to_dict()

def save(self, response_choice=None, async=False, callback=None):
    """ Update object and call given callback in case of async call
        Args:
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Example:
            >>> entity.name = "My Super Object"
            >>> entity.save() # will save the new name in the server
    """
    return self._manage_child_object(nurest_object=self, method=HTTP_METHOD_PUT, async=async, callback=callback, response_choice=response_choice)

def send_request(self, request, async=False, local_callback=None, remote_callback=None, user_info=None):
    """ Sends a request, calls the local callback, then the remote callback in case of async call
        Args:
            request: The request to send
            local_callback: local method that will be triggered in case of async call
            remote_callback: remote moethd that will be triggered in case of async call
            user_info: contains additionnal information to carry during the request
        Returns:
            Returns the object and connection (object, connection)
    """
    callbacks = dict()
    if local_callback:
        callbacks['local'] = local_callback
    if remote_callback:
        callbacks['remote'] = remote_callback
    connection = NURESTConnection(request=request, async=async, callback=self._did_receive_response, callbacks=callbacks)
    connection.user_info = user_info
    return connection.start()

def to_dict(self):
    """ Converts the current object into a Dictionary using all exposed ReST attributes.
        Returns:
            dict: the dictionary containing all the exposed ReST attributes and their values.
        Example::
            >>> print entity.to_dict()
            {"name": "my entity", "description": "Hello World", "ID": "xxxx-xxx-xxxx-xxx", ...}
    """
    dictionary = dict()
    for local_name, attribute in self._attributes.iteritems():
        remote_name = attribute.remote_name
        if hasattr(self, local_name):
            value = getattr(self, local_name)
            # Removed to resolve issue http://mvjira.mv.usa.alcatel.com/browse/VSD-5940 (12/15/2014)
            # if isinstance(value, bool):
            #     value = int(value)
            if isinstance(value, NURESTObject):
                value = value.to_dict()
            if isinstance(value, list) and len(value) > 0 and isinstance(value[0], NURESTObject):
                tmp = list()
                for obj in value:
                    tmp.append(obj.to_dict())
                value = tmp
            dictionary[remote_name] = value
        else:
            pass  # pragma: no cover
    return dictionary

def update_child(self, child):
    """ Update child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    index = None
    for local_child in children:
        if local_child.id == child.id:
            index = children.index(local_child)
            break
    if index is not None:
        children[index] = child

def validate(self):
    """ Validate the current object attributes.
        Check all attributes and store errors
        Returns:
            Returns True if all attibutes of the object
            respect contraints. Returns False otherwise and
            store error in errors dict.
    """
    self._attribute_errors = dict()  # Reset validation errors
    for local_name, attribute in self._attributes.iteritems():
        value = getattr(self, local_name, None)
        if attribute.is_required and (value is None or value == ""):
            self._attribute_errors[local_name] = {'title': 'Invalid input',
                                                  'description': 'This value is mandatory.',
                                                  'remote_name': attribute.remote_name}
            continue
        if value is None:
            continue  # without error
        if type(value) != attribute.attribute_type:
            if attribute.attribute_type != str or type(value) != unicode:
                self._attribute_errors[local_name] = {'title': 'Wrong type',
                                                      'description': 'Attribute %s type should be %s but is %s' % (attribute.remote_name, attribute.attribute_type, type(value)),
                                                      'remote_name': attribute.remote_name}
                continue
        if attribute.min_length and len(value) < attribute.min_length:
            self._attribute_errors[local_name] = {'title': 'Invalid lenght',
                                                  'description': 'Attribute %s minimum size should be %s but is %s' % (attribute.remote_name, attribute.min_length, len(value)),
                                                  'remote_name': attribute.remote_name}
            continue
        if attribute.max_length and len(value) > attribute.max_length:
            self._attribute_errors[local_name] = {'title': 'Invalid lenght',
                                                  'description': 'Attribute %s maximum size should be %s but is %s' % (attribute.remote_name, attribute.max_length, len(value)),
                                                  'remote_name': attribute.remote_name}
            continue
        if attribute.choices and value not in attribute.choices:
            self._attribute_errors[local_name] = {'title': 'Invalid input',
                                                  'description': 'Invalid input',
                                                  'remote_name': attribute.remote_name}
            continue
    return self.is_valid()

def __init__(self, **kwargs):
    """ Initializes a App instance
        Notes:
            You can specify all parameters while calling this methods.
            A special argument named `data` will enable you to load the
            object from a Python dictionary
        Examples:
            >>> app = NUApp(id=u'xxxx-xxx-xxx-xxx', name=u'App')
            >>> app = NUApp(data=my_dict)
    """
    super(NUApp, self).__init__()
    # Read/Write Attributes
    
    self._name = None
    self._last_updated_by = None
    self._description = None
    self._entity_scope = None
    self._assoc_egress_acl_template_id = None
    self._assoc_ingress_acl_template_id = None
    self._associated_domain_id = None
    self._associated_domain_type = None
    self._associated_network_object_id = None
    self._associated_network_object_type = None
    self._external_id = None
    
    self.expose_attribute(local_name="name", remote_name="name", attribute_type=str, is_required=True, is_unique=False)
    self.expose_attribute(local_name="last_updated_by", remote_name="lastUpdatedBy", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="description", remote_name="description", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="entity_scope", remote_name="entityScope", attribute_type=str, is_required=False, is_unique=False, choices=[u'ENTERPRISE', u'GLOBAL'])
    self.expose_attribute(local_name="assoc_egress_acl_template_id", remote_name="assocEgressACLTemplateId", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="assoc_ingress_acl_template_id", remote_name="assocIngressACLTemplateId", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="associated_domain_id", remote_name="associatedDomainID", attribute_type=str, is_required=True, is_unique=False)
    self.expose_attribute(local_name="associated_domain_type", remote_name="associatedDomainType", attribute_type=str, is_required=True, is_unique=False, choices=[u'DOMAIN', u'L2DOMAIN'])
    self.expose_attribute(local_name="associated_network_object_id", remote_name="associatedNetworkObjectID", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="associated_network_object_type", remote_name="associatedNetworkObjectType", attribute_type=str, is_required=False, is_unique=False, choices=[u'DOMAIN', u'ENTERPRISE', u'ZONE'])
    self.expose_attribute(local_name="external_id", remote_name="externalID", attribute_type=str, is_required=False, is_unique=True)
    
    # Fetchers
    
    
    self.metadatas = NUMetadatasFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.tiers = NUTiersFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.global_metadatas = NUGlobalMetadatasFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.flows = NUFlowsFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.jobs = NUJobsFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.event_logs = NUEventLogsFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    self._compute_args(**kwargs)

def add_child(self, child):
    """ Add a child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    if children is None:
        raise InternalConsitencyError('Could not find fetcher with name %s while adding %s in parent %s' % (rest_name, child, self))
    if child not in children:
        child.parent_object = self
        children.append(child)

def assign(self, objects, nurest_object_type, async=False, callback=None, commit=True):
    """ Reference a list of objects into the current resource
        Args:
            objects (list): list of NURESTObject to link
            nurest_object_type (type): Type of the object to link
            callback (function): Callback method that should be fired at the end
        Returns:
            Returns the current object and the connection (object, connection)
        Example:
            >>> entity.assign([entity1, entity2, entity3], NUEntity) # entity1, entity2 and entity3 are now part of the entity
    """
    ids = list()
    for nurest_object in objects:
        ids.append(nurest_object.id)
    url = self.get_resource_url_for_child_type(nurest_object_type)
    request = NURESTRequest(method=HTTP_METHOD_PUT, url=url, data=ids)
    user_info = {'nurest_objects': objects, 'commit': commit}
    if async:
        return self.send_request(request=request,
                                 async=async,
                                 local_callback=self._did_perform_standard_operation,
                                 remote_callback=callback,
                                 user_info=user_info)
    else:
        connection = self.send_request(request=request,
                                       user_info=user_info)
        return self._did_perform_standard_operation(connection)

def copy(self):
    """ Returns a copy of the current object
        Returns:
            A copy of the given object
        Example::
            >>> print entity.to_dict()
            
    """
    return self.__class__(data=self.to_dict())

def create_child(self, nurest_object, response_choice=None, async=False, callback=None, commit=True):
    """ Add given nurest_object to the current object
        For example, to add a child into a parent, you can call
        parent.create_child(nurest_object=child)
        Args:
            nurest_object (bambou.NURESTObject): the NURESTObject object to add
            response_choice (int): Automatically send a response choice when confirmation is needed
            async (bool): should the request be done asynchronously or not
            callback (function): callback containing the object and the connection
        Returns:
            Returns the object and connection (object, connection)
        Example:
            >>> entity = NUEntity(name="Super Entity")
            >>> parent_entity.create_child(entity) # the new entity as been created in the parent_entity
    """
    # if nurest_object.id:
    #     raise InternalConsitencyError("Cannot create a child that already has an ID: %s." % nurest_object)
    return self._manage_child_object(nurest_object=nurest_object,
                                     async=async,
                                     method=HTTP_METHOD_POST,
                                     callback=callback,
                                     handler=self._did_create_child,
                                     response_choice=response_choice,
                                     commit=commit)

def delete(self, response_choice=1, async=False, callback=None):
    """ Delete object and call given callback in case of call.
        Args:
            response_choice (int): Automatically send a response choice when confirmation is needed
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Example:
            >>> entity.delete() # will delete the enterprise from the server
    """
    return self._manage_child_object(nurest_object=self, method=HTTP_METHOD_DELETE, async=async, callback=callback, response_choice=response_choice)

def equals(self, rest_object):
    """ Compare with another object """
    if self._is_dirty:
        return False
    if rest_object is None:
        return False
    if not isinstance(rest_object, NURESTObject):
        raise TypeError('The object is not a NURESTObject %s' % rest_object)
    if self.rest_name != rest_object.rest_name:
        return False
    if self.id and rest_object.id:
        return self.id == rest_object.id
    if self.local_id and rest_object.local_id:
        return self.local_id == rest_object.local_id
    return False

def expose_attribute(self, local_name, attribute_type, remote_name=None, display_name=None, is_required=False, is_readonly=False, max_length=None, min_length=None, is_identifier=False, choices=None, is_unique=False, is_email=False, is_login=False, is_editable=True, is_password=False, can_order=False, can_search=False):
    """ Expose local_name as remote_name
        An exposed attribute `local_name` will be sent within the HTTP request as
        a `remote_name`
    """
    if remote_name is None:
        remote_name = local_name
    if display_name is None:
        display_name = local_name
    attribute = NURemoteAttribute(local_name=local_name, remote_name=remote_name, attribute_type=attribute_type)
    attribute.display_name = display_name
    attribute.is_required = is_required
    attribute.is_readonly = is_readonly
    attribute.min_length = min_length
    attribute.max_length = max_length
    attribute.is_editable = is_editable
    attribute.is_identifier = is_identifier
    attribute.choices = choices
    attribute.is_unique = is_unique
    attribute.is_email = is_email
    attribute.is_login = is_login
    attribute.is_password = is_password
    attribute.can_order = can_order
    attribute.can_search = can_search
    self._attributes[local_name] = attribute

def fetch(self, async=False, callback=None):
    """ Fetch all information about the current object
        Args:
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Returns:
            tuple: (current_fetcher, callee_parent, fetched_bjects, connection)
        Example:
            >>> entity = NUEntity(id="xxx-xxx-xxx-xxx")
            >>> entity.fetch() # will get the entity with id "xxx-xxx-xxx-xxx"
            >>> print entity.name
            "My Entity"
    """
    if self.id is None:
        raise InternalConsitencyError("Cannot fetch an object that does not have an ID")
    request = NURESTRequest(method=HTTP_METHOD_GET, url=self.get_resource_url())
    if async:
        return self.send_request(request=request, async=async, local_callback=self._did_retrieve, remote_callback=callback)
    else:
        connection = self.send_request(request=request)
        return self._did_retrieve(connection)

def fetcher_for_rest_name(self, rest_name):
    """ Returns the children fetcher for the given rest name
        Args:
            rest_name (string): the children rest name
        Returns:
            list: Returns the corresponding fetcher
        Example:
            >>> print entity.fetcher_for_rest_name(NUSubEntity.rest_name)
            
    """
    if rest_name not in self._fetchers_registry:
        return None
    return self._fetchers_registry[rest_name]

def from_dict(self, dictionary):
    """ Sets all the exposed ReST attribues from the given dictionary
        Args:
            dictionary (dict): dictionnary containing the raw object attributes and their values.
        Example:
            >>> info = {"name": "my group", "private": False}
            >>> group = NUGroup()
            >>> group.from_dict(info)
            >>> print "name: %s - private: %s" % (group.name, group.private)
            "name: my group - private: False"
    """
    for remote_name, remote_value in dictionary.iteritems():
        # Check if a local attribute is exposed with the remote_name
        # if no attribute is exposed, return None
        local_name = next((name for name, attribute in self._attributes.iteritems() if attribute.remote_name == remote_name), None)
        if local_name:
            setattr(self, local_name, remote_value)
        else:
            # print('Attribute %s could not be added to object %s' % (remote_name, self))
            pass  # pragma: no cover

def genealogic_ids(self):
    """ Get all genealogic ids
        Returns:
             A list of all parent ids
    """
    ids = []
    parent = self
    while parent:
        ids.append(parent.id)
        parent = parent.parent_object
    return ids

def genealogic_types(self):
    """ Get genealogic types
        Returns:
            Returns a list of all parent types
    """
    types = []
    parent = self
    while parent:
        types.append(parent.rest_name)
        parent = parent.parent_object
    return types

def genealogy_contains_id(self, id):
    """ Check if parents contains an object of type resource_name
        Args:
            id: the id of the resource to find
        Returns:
            Returns True if a parent with specific id has been found. False otherwise.
    """
    ids = self.genealogic_ids()
    return id in ids

def genealogy_contains_type(self, resource_name):
    """ Check if parents contains an object of type resource_name
        Args:
            resource_name: the name of the resource to find
        Returns:
            Returns True if a parent of type has been found. False otherwise.
    """
    resource_names = self.genealogic_types()
    return resource_name in resource_names

def get_attribute_infos(self, local_name):
    """ Get exposed attribute information
        Args:
            local_name: the attribute name
        Returns:
            A dictionary of all information
    """
    if local_name in self._attributes:
        return self._attributes[local_name]
    return None

def get_attributes(self):
    """ Get all attributes information
        Returns:
            Returns a dictionnary containing attribute information
    """
    return self._attributes.values()

def get_formated_creation_date(self, format='%b %Y %d %H:%I:%S'):
    """ Return creation date with a given format. Default is '%b %Y %d %H:%I:%S' """
    if not self._creation_date:
        return None
    date = datetime.datetime.utcfromtimestamp(self._creation_date)
    return date.strftime(format)

def get_resource_url(self):
    """ Get resource complete url """
    name = self.__class__.resource_name
    url = self.__class__.rest_base_url()
    if self.id is not None:
        return "%s/%s/%s" % (url, name, self.id)
    return "%s/%s" % (url, name)

def get_resource_url_for_child_type(self, nurest_object_type):
    """ Get the resource url for the nurest_object type """
    return "%s/%s" % (self.get_resource_url(), nurest_object_type.resource_name)

def instantiate_child(self, nurest_object, from_template, response_choice=None, async=False, callback=None, commit=True):
    """ Instantiate an nurest_object from a template object
        Args:
            nurest_object: the NURESTObject object to add
            from_template: the NURESTObject template object
            callback: callback containing the object and the connection
        Returns:
            Returns the object and connection (object, connection)
        Example:
            >>> parent_entity = NUParentEntity(id="xxxx-xxxx-xxx-xxxx") # create a NUParentEntity with an existing ID (or retrieve one)
            >>> other_entity_template = NUOtherEntityTemplate(id="yyyy-yyyy-yyyy-yyyy") # create a NUOtherEntityTemplate with an existing ID (or retrieve one)
            >>> other_entity_instance = NUOtherEntityInstance(name="my new instance") # create a new NUOtherEntityInstance to be intantiated from other_entity_template
            >>>
            >>> parent_entity.instantiate_child(other_entity_instance, other_entity_template) # instatiate the new domain in the server
    """
    # if nurest_object.id:
    #     raise InternalConsitencyError("Cannot instantiate a child that already has an ID: %s." % nurest_object)
    if not from_template.id:
        raise InternalConsitencyError("Cannot instantiate a child from a template with no ID: %s." % from_template)
    nurest_object.template_id = from_template.id
    return self._manage_child_object(nurest_object=nurest_object,
                                     async=async,
                                     method=HTTP_METHOD_POST,
                                     callback=callback,
                                     handler=self._did_create_child,
                                     response_choice=response_choice,
                                     commit=commit)

def is_owned_by_current_user(self):
    """ Check if the current user owns the object """
    from bambou.nurest_root_object import NURESTRootObject
    root_object = NURESTRootObject.get_default_root_object()
    return self._owner == root_object.id

def is_valid(self):
    """
    """
    return len(self.errors) == 0

@classmethod
def object_with_id(cls, id):
    """ Get a new object with the given id
        Returns:
            Returns a new instance with specified id
    """
    new_object = cls()
    new_object.id = id
    return new_object

def parent_for_matching_rest_name(self, rest_names):
    """ Return parent that matches a rest name """
    parent = self
    while parent:
        if parent.rest_name in rest_names:
            return parent
        parent = parent.parent_object
    return None

def register_fetcher(self, fetcher, rest_name):
    """ Register a children fetcher
    """
    self._fetchers_registry[rest_name] = fetcher

def remove_child(self, child):
    """ Remove a child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    target_child = None
    for local_child in children:
        if local_child.id == child.id:
            target_child = local_child
            break
    if target_child:
        target_child.parent_object = None
        children.remove(target_child)

@classmethod
def rest_base_url(cls):
    """ Override this method to set object base url """
    controller = _NURESTSessionCurrentContext.session.login_controller
    return controller.url

def rest_equals(self, rest_object):
    """ Compare objects REST attributes
    """
    if not self.equals(rest_object):
        return False
    return self.to_dict() == rest_object.to_dict()

def save(self, response_choice=None, async=False, callback=None):
    """ Update object and call given callback in case of async call
        Args:
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Example:
            >>> entity.name = "My Super Object"
            >>> entity.save() # will save the new name in the server
    """
    return self._manage_child_object(nurest_object=self, method=HTTP_METHOD_PUT, async=async, callback=callback, response_choice=response_choice)

def send_request(self, request, async=False, local_callback=None, remote_callback=None, user_info=None):
    """ Sends a request, calls the local callback, then the remote callback in case of async call
        Args:
            request: The request to send
            local_callback: local method that will be triggered in case of async call
            remote_callback: remote moethd that will be triggered in case of async call
            user_info: contains additionnal information to carry during the request
        Returns:
            Returns the object and connection (object, connection)
    """
    callbacks = dict()
    if local_callback:
        callbacks['local'] = local_callback
    if remote_callback:
        callbacks['remote'] = remote_callback
    connection = NURESTConnection(request=request, async=async, callback=self._did_receive_response, callbacks=callbacks)
    connection.user_info = user_info
    return connection.start()

def to_dict(self):
    """ Converts the current object into a Dictionary using all exposed ReST attributes.
        Returns:
            dict: the dictionary containing all the exposed ReST attributes and their values.
        Example::
            >>> print entity.to_dict()
            {"name": "my entity", "description": "Hello World", "ID": "xxxx-xxx-xxxx-xxx", ...}
    """
    dictionary = dict()
    for local_name, attribute in self._attributes.iteritems():
        remote_name = attribute.remote_name
        if hasattr(self, local_name):
            value = getattr(self, local_name)
            # Removed to resolve issue http://mvjira.mv.usa.alcatel.com/browse/VSD-5940 (12/15/2014)
            # if isinstance(value, bool):
            #     value = int(value)
            if isinstance(value, NURESTObject):
                value = value.to_dict()
            if isinstance(value, list) and len(value) > 0 and isinstance(value[0], NURESTObject):
                tmp = list()
                for obj in value:
                    tmp.append(obj.to_dict())
                value = tmp
            dictionary[remote_name] = value
        else:
            pass  # pragma: no cover
    return dictionary

def update_child(self, child):
    """ Update child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    index = None
    for local_child in children:
        if local_child.id == child.id:
            index = children.index(local_child)
            break
    if index is not None:
        children[index] = child

def validate(self):
    """ Validate the current object attributes.
        Check all attributes and store errors
        Returns:
            Returns True if all attibutes of the object
            respect contraints. Returns False otherwise and
            store error in errors dict.
    """
    self._attribute_errors = dict()  # Reset validation errors
    for local_name, attribute in self._attributes.iteritems():
        value = getattr(self, local_name, None)
        if attribute.is_required and (value is None or value == ""):
            self._attribute_errors[local_name] = {'title': 'Invalid input',
                                                  'description': 'This value is mandatory.',
                                                  'remote_name': attribute.remote_name}
            continue
        if value is None:
            continue  # without error
        if type(value) != attribute.attribute_type:
            if attribute.attribute_type != str or type(value) != unicode:
                self._attribute_errors[local_name] = {'title': 'Wrong type',
                                                      'description': 'Attribute %s type should be %s but is %s' % (attribute.remote_name, attribute.attribute_type, type(value)),
                                                      'remote_name': attribute.remote_name}
                continue
        if attribute.min_length and len(value) < attribute.min_length:
            self._attribute_errors[local_name] = {'title': 'Invalid lenght',
                                                  'description': 'Attribute %s minimum size should be %s but is %s' % (attribute.remote_name, attribute.min_length, len(value)),
                                                  'remote_name': attribute.remote_name}
            continue
        if attribute.max_length and len(value) > attribute.max_length:
            self._attribute_errors[local_name] = {'title': 'Invalid lenght',
                                                  'description': 'Attribute %s maximum size should be %s but is %s' % (attribute.remote_name, attribute.max_length, len(value)),
                                                  'remote_name': attribute.remote_name}
            continue
        if attribute.choices and value not in attribute.choices:
            self._attribute_errors[local_name] = {'title': 'Invalid input',
                                                  'description': 'Invalid input',
                                                  'remote_name': attribute.remote_name}
            continue
    return self.is_valid()

def __init__(self, **kwargs):
    """ Initializes a ApplicationService instance
        Notes:
            You can specify all parameters while calling this methods.
            A special argument named `data` will enable you to load the
            object from a Python dictionary
        Examples:
            >>> applicationservice = NUApplicationService(id=u'xxxx-xxx-xxx-xxx', name=u'ApplicationService')
            >>> applicationservice = NUApplicationService(data=my_dict)
    """
    super(NUApplicationService, self).__init__()
    # Read/Write Attributes
    
    self._dscp = None
    self._name = None
    self._last_updated_by = None
    self._description = None
    self._destination_port = None
    self._direction = None
    self._entity_scope = None
    self._source_port = None
    self._protocol = None
    self._ether_type = None
    self._external_id = None
    
    self.expose_attribute(local_name="dscp", remote_name="DSCP", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="name", remote_name="name", attribute_type=str, is_required=True, is_unique=False)
    self.expose_attribute(local_name="last_updated_by", remote_name="lastUpdatedBy", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="description", remote_name="description", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="destination_port", remote_name="destinationPort", attribute_type=str, is_required=True, is_unique=False)
    self.expose_attribute(local_name="direction", remote_name="direction", attribute_type=str, is_required=True, is_unique=False, choices=[u'REFLEXIVE', u'UNIDIRECTIONAL'])
    self.expose_attribute(local_name="entity_scope", remote_name="entityScope", attribute_type=str, is_required=False, is_unique=False, choices=[u'ENTERPRISE', u'GLOBAL'])
    self.expose_attribute(local_name="source_port", remote_name="sourcePort", attribute_type=str, is_required=True, is_unique=False)
    self.expose_attribute(local_name="protocol", remote_name="protocol", attribute_type=str, is_required=True, is_unique=False)
    self.expose_attribute(local_name="ether_type", remote_name="etherType", attribute_type=str, is_required=True, is_unique=False)
    self.expose_attribute(local_name="external_id", remote_name="externalID", attribute_type=str, is_required=False, is_unique=True)
    
    # Fetchers
    
    
    self.metadatas = NUMetadatasFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.global_metadatas = NUGlobalMetadatasFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.event_logs = NUEventLogsFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    self._compute_args(**kwargs)

def add_child(self, child):
    """ Add a child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    if children is None:
        raise InternalConsitencyError('Could not find fetcher with name %s while adding %s in parent %s' % (rest_name, child, self))
    if child not in children:
        child.parent_object = self
        children.append(child)

def assign(self, objects, nurest_object_type, async=False, callback=None, commit=True):
    """ Reference a list of objects into the current resource
        Args:
            objects (list): list of NURESTObject to link
            nurest_object_type (type): Type of the object to link
            callback (function): Callback method that should be fired at the end
        Returns:
            Returns the current object and the connection (object, connection)
        Example:
            >>> entity.assign([entity1, entity2, entity3], NUEntity) # entity1, entity2 and entity3 are now part of the entity
    """
    ids = list()
    for nurest_object in objects:
        ids.append(nurest_object.id)
    url = self.get_resource_url_for_child_type(nurest_object_type)
    request = NURESTRequest(method=HTTP_METHOD_PUT, url=url, data=ids)
    user_info = {'nurest_objects': objects, 'commit': commit}
    if async:
        return self.send_request(request=request,
                                 async=async,
                                 local_callback=self._did_perform_standard_operation,
                                 remote_callback=callback,
                                 user_info=user_info)
    else:
        connection = self.send_request(request=request,
                                       user_info=user_info)
        return self._did_perform_standard_operation(connection)

def copy(self):
    """ Returns a copy of the current object
        Returns:
            A copy of the given object
        Example::
            >>> print entity.to_dict()
            
    """
    return self.__class__(data=self.to_dict())

def create_child(self, nurest_object, response_choice=None, async=False, callback=None, commit=True):
    """ Add given nurest_object to the current object
        For example, to add a child into a parent, you can call
        parent.create_child(nurest_object=child)
        Args:
            nurest_object (bambou.NURESTObject): the NURESTObject object to add
            response_choice (int): Automatically send a response choice when confirmation is needed
            async (bool): should the request be done asynchronously or not
            callback (function): callback containing the object and the connection
        Returns:
            Returns the object and connection (object, connection)
        Example:
            >>> entity = NUEntity(name="Super Entity")
            >>> parent_entity.create_child(entity) # the new entity as been created in the parent_entity
    """
    # if nurest_object.id:
    #     raise InternalConsitencyError("Cannot create a child that already has an ID: %s." % nurest_object)
    return self._manage_child_object(nurest_object=nurest_object,
                                     async=async,
                                     method=HTTP_METHOD_POST,
                                     callback=callback,
                                     handler=self._did_create_child,
                                     response_choice=response_choice,
                                     commit=commit)

def delete(self, response_choice=1, async=False, callback=None):
    """ Delete object and call given callback in case of call.
        Args:
            response_choice (int): Automatically send a response choice when confirmation is needed
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Example:
            >>> entity.delete() # will delete the enterprise from the server
    """
    return self._manage_child_object(nurest_object=self, method=HTTP_METHOD_DELETE, async=async, callback=callback, response_choice=response_choice)

def equals(self, rest_object):
    """ Compare with another object """
    if self._is_dirty:
        return False
    if rest_object is None:
        return False
    if not isinstance(rest_object, NURESTObject):
        raise TypeError('The object is not a NURESTObject %s' % rest_object)
    if self.rest_name != rest_object.rest_name:
        return False
    if self.id and rest_object.id:
        return self.id == rest_object.id
    if self.local_id and rest_object.local_id:
        return self.local_id == rest_object.local_id
    return False

def expose_attribute(self, local_name, attribute_type, remote_name=None, display_name=None, is_required=False, is_readonly=False, max_length=None, min_length=None, is_identifier=False, choices=None, is_unique=False, is_email=False, is_login=False, is_editable=True, is_password=False, can_order=False, can_search=False):
    """ Expose local_name as remote_name
        An exposed attribute `local_name` will be sent within the HTTP request as
        a `remote_name`
    """
    if remote_name is None:
        remote_name = local_name
    if display_name is None:
        display_name = local_name
    attribute = NURemoteAttribute(local_name=local_name, remote_name=remote_name, attribute_type=attribute_type)
    attribute.display_name = display_name
    attribute.is_required = is_required
    attribute.is_readonly = is_readonly
    attribute.min_length = min_length
    attribute.max_length = max_length
    attribute.is_editable = is_editable
    attribute.is_identifier = is_identifier
    attribute.choices = choices
    attribute.is_unique = is_unique
    attribute.is_email = is_email
    attribute.is_login = is_login
    attribute.is_password = is_password
    attribute.can_order = can_order
    attribute.can_search = can_search
    self._attributes[local_name] = attribute

def fetch(self, async=False, callback=None):
    """ Fetch all information about the current object
        Args:
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Returns:
            tuple: (current_fetcher, callee_parent, fetched_bjects, connection)
        Example:
            >>> entity = NUEntity(id="xxx-xxx-xxx-xxx")
            >>> entity.fetch() # will get the entity with id "xxx-xxx-xxx-xxx"
            >>> print entity.name
            "My Entity"
    """
    if self.id is None:
        raise InternalConsitencyError("Cannot fetch an object that does not have an ID")
    request = NURESTRequest(method=HTTP_METHOD_GET, url=self.get_resource_url())
    if async:
        return self.send_request(request=request, async=async, local_callback=self._did_retrieve, remote_callback=callback)
    else:
        connection = self.send_request(request=request)
        return self._did_retrieve(connection)

def fetcher_for_rest_name(self, rest_name):
    """ Returns the children fetcher for the given rest name
        Args:
            rest_name (string): the children rest name
        Returns:
            list: Returns the corresponding fetcher
        Example:
            >>> print entity.fetcher_for_rest_name(NUSubEntity.rest_name)
            
    """
    if rest_name not in self._fetchers_registry:
        return None
    return self._fetchers_registry[rest_name]

def from_dict(self, dictionary):
    """ Sets all the exposed ReST attribues from the given dictionary
        Args:
            dictionary (dict): dictionnary containing the raw object attributes and their values.
        Example:
            >>> info = {"name": "my group", "private": False}
            >>> group = NUGroup()
            >>> group.from_dict(info)
            >>> print "name: %s - private: %s" % (group.name, group.private)
            "name: my group - private: False"
    """
    for remote_name, remote_value in dictionary.iteritems():
        # Check if a local attribute is exposed with the remote_name
        # if no attribute is exposed, return None
        local_name = next((name for name, attribute in self._attributes.iteritems() if attribute.remote_name == remote_name), None)
        if local_name:
            setattr(self, local_name, remote_value)
        else:
            # print('Attribute %s could not be added to object %s' % (remote_name, self))
            pass  # pragma: no cover

def genealogic_ids(self):
    """ Get all genealogic ids
        Returns:
             A list of all parent ids
    """
    ids = []
    parent = self
    while parent:
        ids.append(parent.id)
        parent = parent.parent_object
    return ids

def genealogic_types(self):
    """ Get genealogic types
        Returns:
            Returns a list of all parent types
    """
    types = []
    parent = self
    while parent:
        types.append(parent.rest_name)
        parent = parent.parent_object
    return types

def genealogy_contains_id(self, id):
    """ Check if parents contains an object of type resource_name
        Args:
            id: the id of the resource to find
        Returns:
            Returns True if a parent with specific id has been found. False otherwise.
    """
    ids = self.genealogic_ids()
    return id in ids

def genealogy_contains_type(self, resource_name):
    """ Check if parents contains an object of type resource_name
        Args:
            resource_name: the name of the resource to find
        Returns:
            Returns True if a parent of type has been found. False otherwise.
    """
    resource_names = self.genealogic_types()
    return resource_name in resource_names

def get_attribute_infos(self, local_name):
    """ Get exposed attribute information
        Args:
            local_name: the attribute name
        Returns:
            A dictionary of all information
    """
    if local_name in self._attributes:
        return self._attributes[local_name]
    return None

def get_attributes(self):
    """ Get all attributes information
        Returns:
            Returns a dictionnary containing attribute information
    """
    return self._attributes.values()

def get_formated_creation_date(self, format='%b %Y %d %H:%I:%S'):
    """ Return creation date with a given format. Default is '%b %Y %d %H:%I:%S' """
    if not self._creation_date:
        return None
    date = datetime.datetime.utcfromtimestamp(self._creation_date)
    return date.strftime(format)

def get_resource_url(self):
    """ Get resource complete url """
    name = self.__class__.resource_name
    url = self.__class__.rest_base_url()
    if self.id is not None:
        return "%s/%s/%s" % (url, name, self.id)
    return "%s/%s" % (url, name)

def get_resource_url_for_child_type(self, nurest_object_type):
    """ Get the resource url for the nurest_object type """
    return "%s/%s" % (self.get_resource_url(), nurest_object_type.resource_name)

def instantiate_child(self, nurest_object, from_template, response_choice=None, async=False, callback=None, commit=True):
    """ Instantiate an nurest_object from a template object
        Args:
            nurest_object: the NURESTObject object to add
            from_template: the NURESTObject template object
            callback: callback containing the object and the connection
        Returns:
            Returns the object and connection (object, connection)
        Example:
            >>> parent_entity = NUParentEntity(id="xxxx-xxxx-xxx-xxxx") # create a NUParentEntity with an existing ID (or retrieve one)
            >>> other_entity_template = NUOtherEntityTemplate(id="yyyy-yyyy-yyyy-yyyy") # create a NUOtherEntityTemplate with an existing ID (or retrieve one)
            >>> other_entity_instance = NUOtherEntityInstance(name="my new instance") # create a new NUOtherEntityInstance to be intantiated from other_entity_template
            >>>
            >>> parent_entity.instantiate_child(other_entity_instance, other_entity_template) # instatiate the new domain in the server
    """
    # if nurest_object.id:
    #     raise InternalConsitencyError("Cannot instantiate a child that already has an ID: %s." % nurest_object)
    if not from_template.id:
        raise InternalConsitencyError("Cannot instantiate a child from a template with no ID: %s." % from_template)
    nurest_object.template_id = from_template.id
    return self._manage_child_object(nurest_object=nurest_object,
                                     async=async,
                                     method=HTTP_METHOD_POST,
                                     callback=callback,
                                     handler=self._did_create_child,
                                     response_choice=response_choice,
                                     commit=commit)

def is_owned_by_current_user(self):
    """ Check if the current user owns the object """
    from bambou.nurest_root_object import NURESTRootObject
    root_object = NURESTRootObject.get_default_root_object()
    return self._owner == root_object.id

def is_valid(self):
    """
    """
    return len(self.errors) == 0

@classmethod
def object_with_id(cls, id):
    """ Get a new object with the given id
        Returns:
            Returns a new instance with specified id
    """
    new_object = cls()
    new_object.id = id
    return new_object

def parent_for_matching_rest_name(self, rest_names):
    """ Return parent that matches a rest name """
    parent = self
    while parent:
        if parent.rest_name in rest_names:
            return parent
        parent = parent.parent_object
    return None

def register_fetcher(self, fetcher, rest_name):
    """ Register a children fetcher
    """
    self._fetchers_registry[rest_name] = fetcher

def remove_child(self, child):
    """ Remove a child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    target_child = None
    for local_child in children:
        if local_child.id == child.id:
            target_child = local_child
            break
    if target_child:
        target_child.parent_object = None
        children.remove(target_child)

@classmethod
def rest_base_url(cls):
    """ Override this method to set object base url """
    controller = _NURESTSessionCurrentContext.session.login_controller
    return controller.url

def rest_equals(self, rest_object):
    """ Compare objects REST attributes
    """
    if not self.equals(rest_object):
        return False
    return self.to_dict() == rest_object.to_dict()

def save(self, response_choice=None, async=False, callback=None):
    """ Update object and call given callback in case of async call
        Args:
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Example:
            >>> entity.name = "My Super Object"
            >>> entity.save() # will save the new name in the server
    """
    return self._manage_child_object(nurest_object=self, method=HTTP_METHOD_PUT, async=async, callback=callback, response_choice=response_choice)

def send_request(self, request, async=False, local_callback=None, remote_callback=None, user_info=None):
    """ Sends a request, calls the local callback, then the remote callback in case of async call
        Args:
            request: The request to send
            local_callback: local method that will be triggered in case of async call
            remote_callback: remote moethd that will be triggered in case of async call
            user_info: contains additionnal information to carry during the request
        Returns:
            Returns the object and connection (object, connection)
    """
    callbacks = dict()
    if local_callback:
        callbacks['local'] = local_callback
    if remote_callback:
        callbacks['remote'] = remote_callback
    connection = NURESTConnection(request=request, async=async, callback=self._did_receive_response, callbacks=callbacks)
    connection.user_info = user_info
    return connection.start()

def to_dict(self):
    """ Converts the current object into a Dictionary using all exposed ReST attributes.
        Returns:
            dict: the dictionary containing all the exposed ReST attributes and their values.
        Example::
            >>> print entity.to_dict()
            {"name": "my entity", "description": "Hello World", "ID": "xxxx-xxx-xxxx-xxx", ...}
    """
    dictionary = dict()
    for local_name, attribute in self._attributes.iteritems():
        remote_name = attribute.remote_name
        if hasattr(self, local_name):
            value = getattr(self, local_name)
            # Removed to resolve issue http://mvjira.mv.usa.alcatel.com/browse/VSD-5940 (12/15/2014)
            # if isinstance(value, bool):
            #     value = int(value)
            if isinstance(value, NURESTObject):
                value = value.to_dict()
            if isinstance(value, list) and len(value) > 0 and isinstance(value[0], NURESTObject):
                tmp = list()
                for obj in value:
                    tmp.append(obj.to_dict())
                value = tmp
            dictionary[remote_name] = value
        else:
            pass  # pragma: no cover
    return dictionary

def update_child(self, child):
    """ Update child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    index = None
    for local_child in children:
        if local_child.id == child.id:
            index = children.index(local_child)
            break
    if index is not None:
        children[index] = child

def validate(self):
    """ Validate the current object attributes.
        Check all attributes and store errors
        Returns:
            Returns True if all attibutes of the object
            respect contraints. Returns False otherwise and
            store error in errors dict.
    """
    self._attribute_errors = dict()  # Reset validation errors
    for local_name, attribute in self._attributes.iteritems():
        value = getattr(self, local_name, None)
        if attribute.is_required and (value is None or value == ""):
            self._attribute_errors[local_name] = {'title': 'Invalid input',
                                                  'description': 'This value is mandatory.',
                                                  'remote_name': attribute.remote_name}
            continue
        if value is None:
            continue  # without error
        if type(value) != attribute.attribute_type:
            if attribute.attribute_type != str or type(value) != unicode:
                self._attribute_errors[local_name] = {'title': 'Wrong type',
                                                      'description': 'Attribute %s type should be %s but is %s' % (attribute.remote_name, attribute.attribute_type, type(value)),
                                                      'remote_name': attribute.remote_name}
                continue
        if attribute.min_length and len(value) < attribute.min_length:
            self._attribute_errors[local_name] = {'title': 'Invalid lenght',
                                                  'description': 'Attribute %s minimum size should be %s but is %s' % (attribute.remote_name, attribute.min_length, len(value)),
                                                  'remote_name': attribute.remote_name}
            continue
        if attribute.max_length and len(value) > attribute.max_length:
            self._attribute_errors[local_name] = {'title': 'Invalid lenght',
                                                  'description': 'Attribute %s maximum size should be %s but is %s' % (attribute.remote_name, attribute.max_length, len(value)),
                                                  'remote_name': attribute.remote_name}
            continue
        if attribute.choices and value not in attribute.choices:
            self._attribute_errors[local_name] = {'title': 'Invalid input',
                                                  'description': 'Invalid input',
                                                  'remote_name': attribute.remote_name}
            continue
    return self.is_valid()

def __init__(self, **kwargs):
    """ Initializes a AutoDiscoveredGateway instance
        Notes:
            You can specify all parameters while calling this methods.
            A special argument named `data` will enable you to load the
            object from a Python dictionary
        Examples:
            >>> autodiscoveredgateway = NUAutoDiscoveredGateway(id=u'xxxx-xxx-xxx-xxx', name=u'AutoDiscoveredGateway')
            >>> autodiscoveredgateway = NUAutoDiscoveredGateway(data=my_dict)
    """
    super(NUAutoDiscoveredGateway, self).__init__()
    # Read/Write Attributes
    
    self._name = None
    self._last_updated_by = None
    self._gateway_id = None
    self._peer = None
    self._personality = None
    self._description = None
    self._entity_scope = None
    self._controllers = None
    self._vtep = None
    self._external_id = None
    self._system_id = None
    
    self.expose_attribute(local_name="name", remote_name="name", attribute_type=str, is_required=True, is_unique=False)
    self.expose_attribute(local_name="last_updated_by", remote_name="lastUpdatedBy", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="gateway_id", remote_name="gatewayID", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="peer", remote_name="peer", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="personality", remote_name="personality", attribute_type=str, is_required=True, is_unique=False, choices=[u'DC7X50', u'HARDWARE_VTEP', u'NSG', u'OTHER', u'VRSG', u'VSA', u'VSG'])
    self.expose_attribute(local_name="description", remote_name="description", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="entity_scope", remote_name="entityScope", attribute_type=str, is_required=False, is_unique=False, choices=[u'ENTERPRISE', u'GLOBAL'])
    self.expose_attribute(local_name="controllers", remote_name="controllers", attribute_type=list, is_required=False, is_unique=False)
    self.expose_attribute(local_name="vtep", remote_name="vtep", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="external_id", remote_name="externalID", attribute_type=str, is_required=False, is_unique=True)
    self.expose_attribute(local_name="system_id", remote_name="systemID", attribute_type=str, is_required=False, is_unique=False)
    
    # Fetchers
    
    
    self.wan_services = NUWANServicesFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.metadatas = NUMetadatasFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.global_metadatas = NUGlobalMetadatasFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.ports = NUPortsFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.ns_ports = NUNSPortsFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.event_logs = NUEventLogsFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    self._compute_args(**kwargs)

def add_child(self, child):
    """ Add a child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    if children is None:
        raise InternalConsitencyError('Could not find fetcher with name %s while adding %s in parent %s' % (rest_name, child, self))
    if child not in children:
        child.parent_object = self
        children.append(child)

def assign(self, objects, nurest_object_type, async=False, callback=None, commit=True):
    """ Reference a list of objects into the current resource
        Args:
            objects (list): list of NURESTObject to link
            nurest_object_type (type): Type of the object to link
            callback (function): Callback method that should be fired at the end
        Returns:
            Returns the current object and the connection (object, connection)
        Example:
            >>> entity.assign([entity1, entity2, entity3], NUEntity) # entity1, entity2 and entity3 are now part of the entity
    """
    ids = list()
    for nurest_object in objects:
        ids.append(nurest_object.id)
    url = self.get_resource_url_for_child_type(nurest_object_type)
    request = NURESTRequest(method=HTTP_METHOD_PUT, url=url, data=ids)
    user_info = {'nurest_objects': objects, 'commit': commit}
    if async:
        return self.send_request(request=request,
                                 async=async,
                                 local_callback=self._did_perform_standard_operation,
                                 remote_callback=callback,
                                 user_info=user_info)
    else:
        connection = self.send_request(request=request,
                                       user_info=user_info)
        return self._did_perform_standard_operation(connection)

def copy(self):
    """ Returns a copy of the current object
        Returns:
            A copy of the given object
        Example::
            >>> print entity.to_dict()
            
    """
    return self.__class__(data=self.to_dict())

def create_child(self, nurest_object, response_choice=None, async=False, callback=None, commit=True):
    """ Add given nurest_object to the current object
        For example, to add a child into a parent, you can call
        parent.create_child(nurest_object=child)
        Args:
            nurest_object (bambou.NURESTObject): the NURESTObject object to add
            response_choice (int): Automatically send a response choice when confirmation is needed
            async (bool): should the request be done asynchronously or not
            callback (function): callback containing the object and the connection
        Returns:
            Returns the object and connection (object, connection)
        Example:
            >>> entity = NUEntity(name="Super Entity")
            >>> parent_entity.create_child(entity) # the new entity as been created in the parent_entity
    """
    # if nurest_object.id:
    #     raise InternalConsitencyError("Cannot create a child that already has an ID: %s." % nurest_object)
    return self._manage_child_object(nurest_object=nurest_object,
                                     async=async,
                                     method=HTTP_METHOD_POST,
                                     callback=callback,
                                     handler=self._did_create_child,
                                     response_choice=response_choice,
                                     commit=commit)

def delete(self, response_choice=1, async=False, callback=None):
    """ Delete object and call given callback in case of call.
        Args:
            response_choice (int): Automatically send a response choice when confirmation is needed
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Example:
            >>> entity.delete() # will delete the enterprise from the server
    """
    return self._manage_child_object(nurest_object=self, method=HTTP_METHOD_DELETE, async=async, callback=callback, response_choice=response_choice)

def equals(self, rest_object):
    """ Compare with another object """
    if self._is_dirty:
        return False
    if rest_object is None:
        return False
    if not isinstance(rest_object, NURESTObject):
        raise TypeError('The object is not a NURESTObject %s' % rest_object)
    if self.rest_name != rest_object.rest_name:
        return False
    if self.id and rest_object.id:
        return self.id == rest_object.id
    if self.local_id and rest_object.local_id:
        return self.local_id == rest_object.local_id
    return False

def expose_attribute(self, local_name, attribute_type, remote_name=None, display_name=None, is_required=False, is_readonly=False, max_length=None, min_length=None, is_identifier=False, choices=None, is_unique=False, is_email=False, is_login=False, is_editable=True, is_password=False, can_order=False, can_search=False):
    """ Expose local_name as remote_name
        An exposed attribute `local_name` will be sent within the HTTP request as
        a `remote_name`
    """
    if remote_name is None:
        remote_name = local_name
    if display_name is None:
        display_name = local_name
    attribute = NURemoteAttribute(local_name=local_name, remote_name=remote_name, attribute_type=attribute_type)
    attribute.display_name = display_name
    attribute.is_required = is_required
    attribute.is_readonly = is_readonly
    attribute.min_length = min_length
    attribute.max_length = max_length
    attribute.is_editable = is_editable
    attribute.is_identifier = is_identifier
    attribute.choices = choices
    attribute.is_unique = is_unique
    attribute.is_email = is_email
    attribute.is_login = is_login
    attribute.is_password = is_password
    attribute.can_order = can_order
    attribute.can_search = can_search
    self._attributes[local_name] = attribute

def fetch(self, async=False, callback=None):
    """ Fetch all information about the current object
        Args:
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Returns:
            tuple: (current_fetcher, callee_parent, fetched_bjects, connection)
        Example:
            >>> entity = NUEntity(id="xxx-xxx-xxx-xxx")
            >>> entity.fetch() # will get the entity with id "xxx-xxx-xxx-xxx"
            >>> print entity.name
            "My Entity"
    """
    if self.id is None:
        raise InternalConsitencyError("Cannot fetch an object that does not have an ID")
    request = NURESTRequest(method=HTTP_METHOD_GET, url=self.get_resource_url())
    if async:
        return self.send_request(request=request, async=async, local_callback=self._did_retrieve, remote_callback=callback)
    else:
        connection = self.send_request(request=request)
        return self._did_retrieve(connection)

def fetcher_for_rest_name(self, rest_name):
    """ Returns the children fetcher for the given rest name
        Args:
            rest_name (string): the children rest name
        Returns:
            list: Returns the corresponding fetcher
        Example:
            >>> print entity.fetcher_for_rest_name(NUSubEntity.rest_name)
            
    """
    if rest_name not in self._fetchers_registry:
        return None
    return self._fetchers_registry[rest_name]

def from_dict(self, dictionary):
    """ Sets all the exposed ReST attribues from the given dictionary
        Args:
            dictionary (dict): dictionnary containing the raw object attributes and their values.
        Example:
            >>> info = {"name": "my group", "private": False}
            >>> group = NUGroup()
            >>> group.from_dict(info)
            >>> print "name: %s - private: %s" % (group.name, group.private)
            "name: my group - private: False"
    """
    for remote_name, remote_value in dictionary.iteritems():
        # Check if a local attribute is exposed with the remote_name
        # if no attribute is exposed, return None
        local_name = next((name for name, attribute in self._attributes.iteritems() if attribute.remote_name == remote_name), None)
        if local_name:
            setattr(self, local_name, remote_value)
        else:
            # print('Attribute %s could not be added to object %s' % (remote_name, self))
            pass  # pragma: no cover

def genealogic_ids(self):
    """ Get all genealogic ids
        Returns:
             A list of all parent ids
    """
    ids = []
    parent = self
    while parent:
        ids.append(parent.id)
        parent = parent.parent_object
    return ids

def genealogic_types(self):
    """ Get genealogic types
        Returns:
            Returns a list of all parent types
    """
    types = []
    parent = self
    while parent:
        types.append(parent.rest_name)
        parent = parent.parent_object
    return types

def genealogy_contains_id(self, id):
    """ Check if parents contains an object of type resource_name
        Args:
            id: the id of the resource to find
        Returns:
            Returns True if a parent with specific id has been found. False otherwise.
    """
    ids = self.genealogic_ids()
    return id in ids

def genealogy_contains_type(self, resource_name):
    """ Check if parents contains an object of type resource_name
        Args:
            resource_name: the name of the resource to find
        Returns:
            Returns True if a parent of type has been found. False otherwise.
    """
    resource_names = self.genealogic_types()
    return resource_name in resource_names

def get_attribute_infos(self, local_name):
    """ Get exposed attribute information
        Args:
            local_name: the attribute name
        Returns:
            A dictionary of all information
    """
    if local_name in self._attributes:
        return self._attributes[local_name]
    return None

def get_attributes(self):
    """ Get all attributes information
        Returns:
            Returns a dictionnary containing attribute information
    """
    return self._attributes.values()

def get_formated_creation_date(self, format='%b %Y %d %H:%I:%S'):
    """ Return creation date with a given format. Default is '%b %Y %d %H:%I:%S' """
    if not self._creation_date:
        return None
    date = datetime.datetime.utcfromtimestamp(self._creation_date)
    return date.strftime(format)

def get_resource_url(self):
    """ Get resource complete url """
    name = self.__class__.resource_name
    url = self.__class__.rest_base_url()
    if self.id is not None:
        return "%s/%s/%s" % (url, name, self.id)
    return "%s/%s" % (url, name)

def get_resource_url_for_child_type(self, nurest_object_type):
    """ Get the resource url for the nurest_object type """
    return "%s/%s" % (self.get_resource_url(), nurest_object_type.resource_name)

def instantiate_child(self, nurest_object, from_template, response_choice=None, async=False, callback=None, commit=True):
    """ Instantiate an nurest_object from a template object
        Args:
            nurest_object: the NURESTObject object to add
            from_template: the NURESTObject template object
            callback: callback containing the object and the connection
        Returns:
            Returns the object and connection (object, connection)
        Example:
            >>> parent_entity = NUParentEntity(id="xxxx-xxxx-xxx-xxxx") # create a NUParentEntity with an existing ID (or retrieve one)
            >>> other_entity_template = NUOtherEntityTemplate(id="yyyy-yyyy-yyyy-yyyy") # create a NUOtherEntityTemplate with an existing ID (or retrieve one)
            >>> other_entity_instance = NUOtherEntityInstance(name="my new instance") # create a new NUOtherEntityInstance to be intantiated from other_entity_template
            >>>
            >>> parent_entity.instantiate_child(other_entity_instance, other_entity_template) # instatiate the new domain in the server
    """
    # if nurest_object.id:
    #     raise InternalConsitencyError("Cannot instantiate a child that already has an ID: %s." % nurest_object)
    if not from_template.id:
        raise InternalConsitencyError("Cannot instantiate a child from a template with no ID: %s." % from_template)
    nurest_object.template_id = from_template.id
    return self._manage_child_object(nurest_object=nurest_object,
                                     async=async,
                                     method=HTTP_METHOD_POST,
                                     callback=callback,
                                     handler=self._did_create_child,
                                     response_choice=response_choice,
                                     commit=commit)

def is_owned_by_current_user(self):
    """ Check if the current user owns the object """
    from bambou.nurest_root_object import NURESTRootObject
    root_object = NURESTRootObject.get_default_root_object()
    return self._owner == root_object.id

def is_valid(self):
    """
    """
    return len(self.errors) == 0

@classmethod
def object_with_id(cls, id):
    """ Get a new object with the given id
        Returns:
            Returns a new instance with specified id
    """
    new_object = cls()
    new_object.id = id
    return new_object

def parent_for_matching_rest_name(self, rest_names):
    """ Return parent that matches a rest name """
    parent = self
    while parent:
        if parent.rest_name in rest_names:
            return parent
        parent = parent.parent_object
    return None

def register_fetcher(self, fetcher, rest_name):
    """ Register a children fetcher
    """
    self._fetchers_registry[rest_name] = fetcher

def remove_child(self, child):
    """ Remove a child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    target_child = None
    for local_child in children:
        if local_child.id == child.id:
            target_child = local_child
            break
    if target_child:
        target_child.parent_object = None
        children.remove(target_child)

@classmethod
def rest_base_url(cls):
    """ Override this method to set object base url """
    controller = _NURESTSessionCurrentContext.session.login_controller
    return controller.url

def rest_equals(self, rest_object):
    """ Compare objects REST attributes
    """
    if not self.equals(rest_object):
        return False
    return self.to_dict() == rest_object.to_dict()

def save(self, response_choice=None, async=False, callback=None):
    """ Update object and call given callback in case of async call
        Args:
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Example:
            >>> entity.name = "My Super Object"
            >>> entity.save() # will save the new name in the server
    """
    return self._manage_child_object(nurest_object=self, method=HTTP_METHOD_PUT, async=async, callback=callback, response_choice=response_choice)

def send_request(self, request, async=False, local_callback=None, remote_callback=None, user_info=None):
    """ Sends a request, calls the local callback, then the remote callback in case of async call
        Args:
            request: The request to send
            local_callback: local method that will be triggered in case of async call
            remote_callback: remote moethd that will be triggered in case of async call
            user_info: contains additionnal information to carry during the request
        Returns:
            Returns the object and connection (object, connection)
    """
    callbacks = dict()
    if local_callback:
        callbacks['local'] = local_callback
    if remote_callback:
        callbacks['remote'] = remote_callback
    connection = NURESTConnection(request=request, async=async, callback=self._did_receive_response, callbacks=callbacks)
    connection.user_info = user_info
    return connection.start()

def to_dict(self):
    """ Converts the current object into a Dictionary using all exposed ReST attributes.
        Returns:
            dict: the dictionary containing all the exposed ReST attributes and their values.
        Example::
            >>> print entity.to_dict()
            {"name": "my entity", "description": "Hello World", "ID": "xxxx-xxx-xxxx-xxx", ...}
    """
    dictionary = dict()
    for local_name, attribute in self._attributes.iteritems():
        remote_name = attribute.remote_name
        if hasattr(self, local_name):
            value = getattr(self, local_name)
            # Removed to resolve issue http://mvjira.mv.usa.alcatel.com/browse/VSD-5940 (12/15/2014)
            # if isinstance(value, bool):
            #     value = int(value)
            if isinstance(value, NURESTObject):
                value = value.to_dict()
            if isinstance(value, list) and len(value) > 0 and isinstance(value[0], NURESTObject):
                tmp = list()
                for obj in value:
                    tmp.append(obj.to_dict())
                value = tmp
            dictionary[remote_name] = value
        else:
            pass  # pragma: no cover
    return dictionary

def update_child(self, child):
    """ Update child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    index = None
    for local_child in children:
        if local_child.id == child.id:
            index = children.index(local_child)
            break
    if index is not None:
        children[index] = child

def validate(self):
    """ Validate the current object attributes.
        Check all attributes and store errors
        Returns:
            Returns True if all attibutes of the object
            respect contraints. Returns False otherwise and
            store error in errors dict.
    """
    self._attribute_errors = dict()  # Reset validation errors
    for local_name, attribute in self._attributes.iteritems():
        value = getattr(self, local_name, None)
        if attribute.is_required and (value is None or value == ""):
            self._attribute_errors[local_name] = {'title': 'Invalid input',
                                                  'description': 'This value is mandatory.',
                                                  'remote_name': attribute.remote_name}
            continue
        if value is None:
            continue  # without error
        if type(value) != attribute.attribute_type:
            if attribute.attribute_type != str or type(value) != unicode:
                self._attribute_errors[local_name] = {'title': 'Wrong type',
                                                      'description': 'Attribute %s type should be %s but is %s' % (attribute.remote_name, attribute.attribute_type, type(value)),
                                                      'remote_name': attribute.remote_name}
                continue
        if attribute.min_length and len(value) < attribute.min_length:
            self._attribute_errors[local_name] = {'title': 'Invalid lenght',
                                                  'description': 'Attribute %s minimum size should be %s but is %s' % (attribute.remote_name, attribute.min_length, len(value)),
                                                  'remote_name': attribute.remote_name}
            continue
        if attribute.max_length and len(value) > attribute.max_length:
            self._attribute_errors[local_name] = {'title': 'Invalid lenght',
                                                  'description': 'Attribute %s maximum size should be %s but is %s' % (attribute.remote_name, attribute.max_length, len(value)),
                                                  'remote_name': attribute.remote_name}
            continue
        if attribute.choices and value not in attribute.choices:
            self._attribute_errors[local_name] = {'title': 'Invalid input',
                                                  'description': 'Invalid input',
                                                  'remote_name': attribute.remote_name}
            continue
    return self.is_valid()

def __init__(self, **kwargs):
    """ Initializes a BGPPeer instance
        Notes:
            You can specify all parameters while calling this methods.
            A special argument named `data` will enable you to load the
            object from a Python dictionary
        Examples:
            >>> bgppeer = NUBGPPeer(id=u'xxxx-xxx-xxx-xxx', name=u'BGPPeer')
            >>> bgppeer = NUBGPPeer(data=my_dict)
    """
    super(NUBGPPeer, self).__init__()
    # Read/Write Attributes
    
    self._last_state_change = None
    self._address = None
    self._entity_scope = None
    self._status = None
    self._external_id = None
    
    self.expose_attribute(local_name="last_state_change", remote_name="lastStateChange", attribute_type=int, is_required=False, is_unique=False)
    self.expose_attribute(local_name="address", remote_name="address", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="entity_scope", remote_name="entityScope", attribute_type=str, is_required=False, is_unique=False, choices=[u'ENTERPRISE', u'GLOBAL'])
    self.expose_attribute(local_name="status", remote_name="status", attribute_type=str, is_required=False, is_unique=False, choices=[u'ADMIN_DOWN', u'DOWN', u'UP'])
    self.expose_attribute(local_name="external_id", remote_name="externalID", attribute_type=str, is_required=False, is_unique=True)
    
    # Fetchers
    
    
    self.metadatas = NUMetadatasFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.global_metadatas = NUGlobalMetadatasFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    self._compute_args(**kwargs)

def add_child(self, child):
    """ Add a child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    if children is None:
        raise InternalConsitencyError('Could not find fetcher with name %s while adding %s in parent %s' % (rest_name, child, self))
    if child not in children:
        child.parent_object = self
        children.append(child)

def assign(self, objects, nurest_object_type, async=False, callback=None, commit=True):
    """ Reference a list of objects into the current resource
        Args:
            objects (list): list of NURESTObject to link
            nurest_object_type (type): Type of the object to link
            callback (function): Callback method that should be fired at the end
        Returns:
            Returns the current object and the connection (object, connection)
        Example:
            >>> entity.assign([entity1, entity2, entity3], NUEntity) # entity1, entity2 and entity3 are now part of the entity
    """
    ids = list()
    for nurest_object in objects:
        ids.append(nurest_object.id)
    url = self.get_resource_url_for_child_type(nurest_object_type)
    request = NURESTRequest(method=HTTP_METHOD_PUT, url=url, data=ids)
    user_info = {'nurest_objects': objects, 'commit': commit}
    if async:
        return self.send_request(request=request,
                                 async=async,
                                 local_callback=self._did_perform_standard_operation,
                                 remote_callback=callback,
                                 user_info=user_info)
    else:
        connection = self.send_request(request=request,
                                       user_info=user_info)
        return self._did_perform_standard_operation(connection)

def copy(self):
    """ Returns a copy of the current object
        Returns:
            A copy of the given object
        Example::
            >>> print entity.to_dict()
            
    """
    return self.__class__(data=self.to_dict())

def create_child(self, nurest_object, response_choice=None, async=False, callback=None, commit=True):
    """ Add given nurest_object to the current object
        For example, to add a child into a parent, you can call
        parent.create_child(nurest_object=child)
        Args:
            nurest_object (bambou.NURESTObject): the NURESTObject object to add
            response_choice (int): Automatically send a response choice when confirmation is needed
            async (bool): should the request be done asynchronously or not
            callback (function): callback containing the object and the connection
        Returns:
            Returns the object and connection (object, connection)
        Example:
            >>> entity = NUEntity(name="Super Entity")
            >>> parent_entity.create_child(entity) # the new entity as been created in the parent_entity
    """
    # if nurest_object.id:
    #     raise InternalConsitencyError("Cannot create a child that already has an ID: %s." % nurest_object)
    return self._manage_child_object(nurest_object=nurest_object,
                                     async=async,
                                     method=HTTP_METHOD_POST,
                                     callback=callback,
                                     handler=self._did_create_child,
                                     response_choice=response_choice,
                                     commit=commit)

def delete(self, response_choice=1, async=False, callback=None):
    """ Delete object and call given callback in case of call.
        Args:
            response_choice (int): Automatically send a response choice when confirmation is needed
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Example:
            >>> entity.delete() # will delete the enterprise from the server
    """
    return self._manage_child_object(nurest_object=self, method=HTTP_METHOD_DELETE, async=async, callback=callback, response_choice=response_choice)

def equals(self, rest_object):
    """ Compare with another object """
    if self._is_dirty:
        return False
    if rest_object is None:
        return False
    if not isinstance(rest_object, NURESTObject):
        raise TypeError('The object is not a NURESTObject %s' % rest_object)
    if self.rest_name != rest_object.rest_name:
        return False
    if self.id and rest_object.id:
        return self.id == rest_object.id
    if self.local_id and rest_object.local_id:
        return self.local_id == rest_object.local_id
    return False

def expose_attribute(self, local_name, attribute_type, remote_name=None, display_name=None, is_required=False, is_readonly=False, max_length=None, min_length=None, is_identifier=False, choices=None, is_unique=False, is_email=False, is_login=False, is_editable=True, is_password=False, can_order=False, can_search=False):
    """ Expose local_name as remote_name
        An exposed attribute `local_name` will be sent within the HTTP request as
        a `remote_name`
    """
    if remote_name is None:
        remote_name = local_name
    if display_name is None:
        display_name = local_name
    attribute = NURemoteAttribute(local_name=local_name, remote_name=remote_name, attribute_type=attribute_type)
    attribute.display_name = display_name
    attribute.is_required = is_required
    attribute.is_readonly = is_readonly
    attribute.min_length = min_length
    attribute.max_length = max_length
    attribute.is_editable = is_editable
    attribute.is_identifier = is_identifier
    attribute.choices = choices
    attribute.is_unique = is_unique
    attribute.is_email = is_email
    attribute.is_login = is_login
    attribute.is_password = is_password
    attribute.can_order = can_order
    attribute.can_search = can_search
    self._attributes[local_name] = attribute

def fetch(self, async=False, callback=None):
    """ Fetch all information about the current object
        Args:
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Returns:
            tuple: (current_fetcher, callee_parent, fetched_bjects, connection)
        Example:
            >>> entity = NUEntity(id="xxx-xxx-xxx-xxx")
            >>> entity.fetch() # will get the entity with id "xxx-xxx-xxx-xxx"
            >>> print entity.name
            "My Entity"
    """
    if self.id is None:
        raise InternalConsitencyError("Cannot fetch an object that does not have an ID")
    request = NURESTRequest(method=HTTP_METHOD_GET, url=self.get_resource_url())
    if async:
        return self.send_request(request=request, async=async, local_callback=self._did_retrieve, remote_callback=callback)
    else:
        connection = self.send_request(request=request)
        return self._did_retrieve(connection)

def fetcher_for_rest_name(self, rest_name):
    """ Returns the children fetcher for the given rest name
        Args:
            rest_name (string): the children rest name
        Returns:
            list: Returns the corresponding fetcher
        Example:
            >>> print entity.fetcher_for_rest_name(NUSubEntity.rest_name)
            
    """
    if rest_name not in self._fetchers_registry:
        return None
    return self._fetchers_registry[rest_name]

def from_dict(self, dictionary):
    """ Sets all the exposed ReST attribues from the given dictionary
        Args:
            dictionary (dict): dictionnary containing the raw object attributes and their values.
        Example:
            >>> info = {"name": "my group", "private": False}
            >>> group = NUGroup()
            >>> group.from_dict(info)
            >>> print "name: %s - private: %s" % (group.name, group.private)
            "name: my group - private: False"
    """
    for remote_name, remote_value in dictionary.iteritems():
        # Check if a local attribute is exposed with the remote_name
        # if no attribute is exposed, return None
        local_name = next((name for name, attribute in self._attributes.iteritems() if attribute.remote_name == remote_name), None)
        if local_name:
            setattr(self, local_name, remote_value)
        else:
            # print('Attribute %s could not be added to object %s' % (remote_name, self))
            pass  # pragma: no cover

def genealogic_ids(self):
    """ Get all genealogic ids
        Returns:
             A list of all parent ids
    """
    ids = []
    parent = self
    while parent:
        ids.append(parent.id)
        parent = parent.parent_object
    return ids

def genealogic_types(self):
    """ Get genealogic types
        Returns:
            Returns a list of all parent types
    """
    types = []
    parent = self
    while parent:
        types.append(parent.rest_name)
        parent = parent.parent_object
    return types

def genealogy_contains_id(self, id):
    """ Check if parents contains an object of type resource_name
        Args:
            id: the id of the resource to find
        Returns:
            Returns True if a parent with specific id has been found. False otherwise.
    """
    ids = self.genealogic_ids()
    return id in ids

def genealogy_contains_type(self, resource_name):
    """ Check if parents contains an object of type resource_name
        Args:
            resource_name: the name of the resource to find
        Returns:
            Returns True if a parent of type has been found. False otherwise.
    """
    resource_names = self.genealogic_types()
    return resource_name in resource_names

def get_attribute_infos(self, local_name):
    """ Get exposed attribute information
        Args:
            local_name: the attribute name
        Returns:
            A dictionary of all information
    """
    if local_name in self._attributes:
        return self._attributes[local_name]
    return None

def get_attributes(self):
    """ Get all attributes information
        Returns:
            Returns a dictionnary containing attribute information
    """
    return self._attributes.values()

def get_formated_creation_date(self, format='%b %Y %d %H:%I:%S'):
    """ Return creation date with a given format. Default is '%b %Y %d %H:%I:%S' """
    if not self._creation_date:
        return None
    date = datetime.datetime.utcfromtimestamp(self._creation_date)
    return date.strftime(format)

def get_resource_url(self):
    """ Get resource complete url """
    name = self.__class__.resource_name
    url = self.__class__.rest_base_url()
    if self.id is not None:
        return "%s/%s/%s" % (url, name, self.id)
    return "%s/%s" % (url, name)

def get_resource_url_for_child_type(self, nurest_object_type):
    """ Get the resource url for the nurest_object type """
    return "%s/%s" % (self.get_resource_url(), nurest_object_type.resource_name)

def instantiate_child(self, nurest_object, from_template, response_choice=None, async=False, callback=None, commit=True):
    """ Instantiate an nurest_object from a template object
        Args:
            nurest_object: the NURESTObject object to add
            from_template: the NURESTObject template object
            callback: callback containing the object and the connection
        Returns:
            Returns the object and connection (object, connection)
        Example:
            >>> parent_entity = NUParentEntity(id="xxxx-xxxx-xxx-xxxx") # create a NUParentEntity with an existing ID (or retrieve one)
            >>> other_entity_template = NUOtherEntityTemplate(id="yyyy-yyyy-yyyy-yyyy") # create a NUOtherEntityTemplate with an existing ID (or retrieve one)
            >>> other_entity_instance = NUOtherEntityInstance(name="my new instance") # create a new NUOtherEntityInstance to be intantiated from other_entity_template
            >>>
            >>> parent_entity.instantiate_child(other_entity_instance, other_entity_template) # instatiate the new domain in the server
    """
    # if nurest_object.id:
    #     raise InternalConsitencyError("Cannot instantiate a child that already has an ID: %s." % nurest_object)
    if not from_template.id:
        raise InternalConsitencyError("Cannot instantiate a child from a template with no ID: %s." % from_template)
    nurest_object.template_id = from_template.id
    return self._manage_child_object(nurest_object=nurest_object,
                                     async=async,
                                     method=HTTP_METHOD_POST,
                                     callback=callback,
                                     handler=self._did_create_child,
                                     response_choice=response_choice,
                                     commit=commit)

def is_owned_by_current_user(self):
    """ Check if the current user owns the object """
    from bambou.nurest_root_object import NURESTRootObject
    root_object = NURESTRootObject.get_default_root_object()
    return self._owner == root_object.id

def is_valid(self):
    """
    """
    return len(self.errors) == 0

@classmethod
def object_with_id(cls, id):
    """ Get a new object with the given id
        Returns:
            Returns a new instance with specified id
    """
    new_object = cls()
    new_object.id = id
    return new_object

def parent_for_matching_rest_name(self, rest_names):
    """ Return parent that matches a rest name """
    parent = self
    while parent:
        if parent.rest_name in rest_names:
            return parent
        parent = parent.parent_object
    return None

def register_fetcher(self, fetcher, rest_name):
    """ Register a children fetcher
    """
    self._fetchers_registry[rest_name] = fetcher

def remove_child(self, child):
    """ Remove a child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    target_child = None
    for local_child in children:
        if local_child.id == child.id:
            target_child = local_child
            break
    if target_child:
        target_child.parent_object = None
        children.remove(target_child)

@classmethod
def rest_base_url(cls):
    """ Override this method to set object base url """
    controller = _NURESTSessionCurrentContext.session.login_controller
    return controller.url

def rest_equals(self, rest_object):
    """ Compare objects REST attributes
    """
    if not self.equals(rest_object):
        return False
    return self.to_dict() == rest_object.to_dict()

def save(self, response_choice=None, async=False, callback=None):
    """ Update object and call given callback in case of async call
        Args:
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Example:
            >>> entity.name = "My Super Object"
            >>> entity.save() # will save the new name in the server
    """
    return self._manage_child_object(nurest_object=self, method=HTTP_METHOD_PUT, async=async, callback=callback, response_choice=response_choice)

def send_request(self, request, async=False, local_callback=None, remote_callback=None, user_info=None):
    """ Sends a request, calls the local callback, then the remote callback in case of async call
        Args:
            request: The request to send
            local_callback: local method that will be triggered in case of async call
            remote_callback: remote moethd that will be triggered in case of async call
            user_info: contains additionnal information to carry during the request
        Returns:
            Returns the object and connection (object, connection)
    """
    callbacks = dict()
    if local_callback:
        callbacks['local'] = local_callback
    if remote_callback:
        callbacks['remote'] = remote_callback
    connection = NURESTConnection(request=request, async=async, callback=self._did_receive_response, callbacks=callbacks)
    connection.user_info = user_info
    return connection.start()

def to_dict(self):
    """ Converts the current object into a Dictionary using all exposed ReST attributes.
        Returns:
            dict: the dictionary containing all the exposed ReST attributes and their values.
        Example::
            >>> print entity.to_dict()
            {"name": "my entity", "description": "Hello World", "ID": "xxxx-xxx-xxxx-xxx", ...}
    """
    dictionary = dict()
    for local_name, attribute in self._attributes.iteritems():
        remote_name = attribute.remote_name
        if hasattr(self, local_name):
            value = getattr(self, local_name)
            # Removed to resolve issue http://mvjira.mv.usa.alcatel.com/browse/VSD-5940 (12/15/2014)
            # if isinstance(value, bool):
            #     value = int(value)
            if isinstance(value, NURESTObject):
                value = value.to_dict()
            if isinstance(value, list) and len(value) > 0 and isinstance(value[0], NURESTObject):
                tmp = list()
                for obj in value:
                    tmp.append(obj.to_dict())
                value = tmp
            dictionary[remote_name] = value
        else:
            pass  # pragma: no cover
    return dictionary

def update_child(self, child):
    """ Update child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    index = None
    for local_child in children:
        if local_child.id == child.id:
            index = children.index(local_child)
            break
    if index is not None:
        children[index] = child

def validate(self):
    """ Validate the current object attributes.
        Check all attributes and store errors
        Returns:
            Returns True if all attibutes of the object
            respect contraints. Returns False otherwise and
            store error in errors dict.
    """
    self._attribute_errors = dict()  # Reset validation errors
    for local_name, attribute in self._attributes.iteritems():
        value = getattr(self, local_name, None)
        if attribute.is_required and (value is None or value == ""):
            self._attribute_errors[local_name] = {'title': 'Invalid input',
                                                  'description': 'This value is mandatory.',
                                                  'remote_name': attribute.remote_name}
            continue
        if value is None:
            continue  # without error
        if type(value) != attribute.attribute_type:
            if attribute.attribute_type != str or type(value) != unicode:
                self._attribute_errors[local_name] = {'title': 'Wrong type',
                                                      'description': 'Attribute %s type should be %s but is %s' % (attribute.remote_name, attribute.attribute_type, type(value)),
                                                      'remote_name': attribute.remote_name}
                continue
        if attribute.min_length and len(value) < attribute.min_length:
            self._attribute_errors[local_name] = {'title': 'Invalid lenght',
                                                  'description': 'Attribute %s minimum size should be %s but is %s' % (attribute.remote_name, attribute.min_length, len(value)),
                                                  'remote_name': attribute.remote_name}
            continue
        if attribute.max_length and len(value) > attribute.max_length:
            self._attribute_errors[local_name] = {'title': 'Invalid lenght',
                                                  'description': 'Attribute %s maximum size should be %s but is %s' % (attribute.remote_name, attribute.max_length, len(value)),
                                                  'remote_name': attribute.remote_name}
            continue
        if attribute.choices and value not in attribute.choices:
            self._attribute_errors[local_name] = {'title': 'Invalid input',
                                                  'description': 'Invalid input',
                                                  'remote_name': attribute.remote_name}
            continue
    return self.is_valid()

def __init__(self, **kwargs):
    """ Initializes a Bootstrap instance
        Notes:
            You can specify all parameters while calling this methods.
            A special argument named `data` will enable you to load the
            object from a Python dictionary
        Examples:
            >>> bootstrap = NUBootstrap(id=u'xxxx-xxx-xxx-xxx', name=u'Bootstrap')
            >>> bootstrap = NUBootstrap(data=my_dict)
    """
    super(NUBootstrap, self).__init__()
    # Read/Write Attributes
    
    self._last_updated_by = None
    self._installer_id = None
    self._entity_scope = None
    self._status = None
    self._external_id = None
    
    self.expose_attribute(local_name="last_updated_by", remote_name="lastUpdatedBy", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="installer_id", remote_name="installerID", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="entity_scope", remote_name="entityScope", attribute_type=str, is_required=False, is_unique=False, choices=[u'ENTERPRISE', u'GLOBAL'])
    self.expose_attribute(local_name="status", remote_name="status", attribute_type=str, is_required=False, is_unique=False, choices=[u'ACTIVE', u'CERTIFICATE_SIGNED', u'INACTIVE', u'NOTIFICATION_APP_REQ_ACK', u'NOTIFICATION_APP_REQ_SENT'])
    self.expose_attribute(local_name="external_id", remote_name="externalID", attribute_type=str, is_required=False, is_unique=True)
    
    # Fetchers
    
    
    self.metadatas = NUMetadatasFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.global_metadatas = NUGlobalMetadatasFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    self._compute_args(**kwargs)

def add_child(self, child):
    """ Add a child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    if children is None:
        raise InternalConsitencyError('Could not find fetcher with name %s while adding %s in parent %s' % (rest_name, child, self))
    if child not in children:
        child.parent_object = self
        children.append(child)

def assign(self, objects, nurest_object_type, async=False, callback=None, commit=True):
    """ Reference a list of objects into the current resource
        Args:
            objects (list): list of NURESTObject to link
            nurest_object_type (type): Type of the object to link
            callback (function): Callback method that should be fired at the end
        Returns:
            Returns the current object and the connection (object, connection)
        Example:
            >>> entity.assign([entity1, entity2, entity3], NUEntity) # entity1, entity2 and entity3 are now part of the entity
    """
    ids = list()
    for nurest_object in objects:
        ids.append(nurest_object.id)
    url = self.get_resource_url_for_child_type(nurest_object_type)
    request = NURESTRequest(method=HTTP_METHOD_PUT, url=url, data=ids)
    user_info = {'nurest_objects': objects, 'commit': commit}
    if async:
        return self.send_request(request=request,
                                 async=async,
                                 local_callback=self._did_perform_standard_operation,
                                 remote_callback=callback,
                                 user_info=user_info)
    else:
        connection = self.send_request(request=request,
                                       user_info=user_info)
        return self._did_perform_standard_operation(connection)

def copy(self):
    """ Returns a copy of the current object
        Returns:
            A copy of the given object
        Example::
            >>> print entity.to_dict()
            
    """
    return self.__class__(data=self.to_dict())

def create_child(self, nurest_object, response_choice=None, async=False, callback=None, commit=True):
    """ Add given nurest_object to the current object
        For example, to add a child into a parent, you can call
        parent.create_child(nurest_object=child)
        Args:
            nurest_object (bambou.NURESTObject): the NURESTObject object to add
            response_choice (int): Automatically send a response choice when confirmation is needed
            async (bool): should the request be done asynchronously or not
            callback (function): callback containing the object and the connection
        Returns:
            Returns the object and connection (object, connection)
        Example:
            >>> entity = NUEntity(name="Super Entity")
            >>> parent_entity.create_child(entity) # the new entity as been created in the parent_entity
    """
    # if nurest_object.id:
    #     raise InternalConsitencyError("Cannot create a child that already has an ID: %s." % nurest_object)
    return self._manage_child_object(nurest_object=nurest_object,
                                     async=async,
                                     method=HTTP_METHOD_POST,
                                     callback=callback,
                                     handler=self._did_create_child,
                                     response_choice=response_choice,
                                     commit=commit)

def delete(self, response_choice=1, async=False, callback=None):
    """ Delete object and call given callback in case of call.
        Args:
            response_choice (int): Automatically send a response choice when confirmation is needed
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Example:
            >>> entity.delete() # will delete the enterprise from the server
    """
    return self._manage_child_object(nurest_object=self, method=HTTP_METHOD_DELETE, async=async, callback=callback, response_choice=response_choice)

def equals(self, rest_object):
    """ Compare with another object """
    if self._is_dirty:
        return False
    if rest_object is None:
        return False
    if not isinstance(rest_object, NURESTObject):
        raise TypeError('The object is not a NURESTObject %s' % rest_object)
    if self.rest_name != rest_object.rest_name:
        return False
    if self.id and rest_object.id:
        return self.id == rest_object.id
    if self.local_id and rest_object.local_id:
        return self.local_id == rest_object.local_id
    return False

def expose_attribute(self, local_name, attribute_type, remote_name=None, display_name=None, is_required=False, is_readonly=False, max_length=None, min_length=None, is_identifier=False, choices=None, is_unique=False, is_email=False, is_login=False, is_editable=True, is_password=False, can_order=False, can_search=False):
    """ Expose local_name as remote_name
        An exposed attribute `local_name` will be sent within the HTTP request as
        a `remote_name`
    """
    if remote_name is None:
        remote_name = local_name
    if display_name is None:
        display_name = local_name
    attribute = NURemoteAttribute(local_name=local_name, remote_name=remote_name, attribute_type=attribute_type)
    attribute.display_name = display_name
    attribute.is_required = is_required
    attribute.is_readonly = is_readonly
    attribute.min_length = min_length
    attribute.max_length = max_length
    attribute.is_editable = is_editable
    attribute.is_identifier = is_identifier
    attribute.choices = choices
    attribute.is_unique = is_unique
    attribute.is_email = is_email
    attribute.is_login = is_login
    attribute.is_password = is_password
    attribute.can_order = can_order
    attribute.can_search = can_search
    self._attributes[local_name] = attribute

def fetch(self, async=False, callback=None):
    """ Fetch all information about the current object
        Args:
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Returns:
            tuple: (current_fetcher, callee_parent, fetched_bjects, connection)
        Example:
            >>> entity = NUEntity(id="xxx-xxx-xxx-xxx")
            >>> entity.fetch() # will get the entity with id "xxx-xxx-xxx-xxx"
            >>> print entity.name
            "My Entity"
    """
    if self.id is None:
        raise InternalConsitencyError("Cannot fetch an object that does not have an ID")
    request = NURESTRequest(method=HTTP_METHOD_GET, url=self.get_resource_url())
    if async:
        return self.send_request(request=request, async=async, local_callback=self._did_retrieve, remote_callback=callback)
    else:
        connection = self.send_request(request=request)
        return self._did_retrieve(connection)

def fetcher_for_rest_name(self, rest_name):
    """ Returns the children fetcher for the given rest name
        Args:
            rest_name (string): the children rest name
        Returns:
            list: Returns the corresponding fetcher
        Example:
            >>> print entity.fetcher_for_rest_name(NUSubEntity.rest_name)
            
    """
    if rest_name not in self._fetchers_registry:
        return None
    return self._fetchers_registry[rest_name]

def from_dict(self, dictionary):
    """ Sets all the exposed ReST attribues from the given dictionary
        Args:
            dictionary (dict): dictionnary containing the raw object attributes and their values.
        Example:
            >>> info = {"name": "my group", "private": False}
            >>> group = NUGroup()
            >>> group.from_dict(info)
            >>> print "name: %s - private: %s" % (group.name, group.private)
            "name: my group - private: False"
    """
    for remote_name, remote_value in dictionary.iteritems():
        # Check if a local attribute is exposed with the remote_name
        # if no attribute is exposed, return None
        local_name = next((name for name, attribute in self._attributes.iteritems() if attribute.remote_name == remote_name), None)
        if local_name:
            setattr(self, local_name, remote_value)
        else:
            # print('Attribute %s could not be added to object %s' % (remote_name, self))
            pass  # pragma: no cover

def genealogic_ids(self):
    """ Get all genealogic ids
        Returns:
             A list of all parent ids
    """
    ids = []
    parent = self
    while parent:
        ids.append(parent.id)
        parent = parent.parent_object
    return ids

def genealogic_types(self):
    """ Get genealogic types
        Returns:
            Returns a list of all parent types
    """
    types = []
    parent = self
    while parent:
        types.append(parent.rest_name)
        parent = parent.parent_object
    return types

def genealogy_contains_id(self, id):
    """ Check if parents contains an object of type resource_name
        Args:
            id: the id of the resource to find
        Returns:
            Returns True if a parent with specific id has been found. False otherwise.
    """
    ids = self.genealogic_ids()
    return id in ids

def genealogy_contains_type(self, resource_name):
    """ Check if parents contains an object of type resource_name
        Args:
            resource_name: the name of the resource to find
        Returns:
            Returns True if a parent of type has been found. False otherwise.
    """
    resource_names = self.genealogic_types()
    return resource_name in resource_names

def get_attribute_infos(self, local_name):
    """ Get exposed attribute information
        Args:
            local_name: the attribute name
        Returns:
            A dictionary of all information
    """
    if local_name in self._attributes:
        return self._attributes[local_name]
    return None

def get_attributes(self):
    """ Get all attributes information
        Returns:
            Returns a dictionnary containing attribute information
    """
    return self._attributes.values()

def get_formated_creation_date(self, format='%b %Y %d %H:%I:%S'):
    """ Return creation date with a given format. Default is '%b %Y %d %H:%I:%S' """
    if not self._creation_date:
        return None
    date = datetime.datetime.utcfromtimestamp(self._creation_date)
    return date.strftime(format)

def get_resource_url(self):
    """ Get resource complete url """
    name = self.__class__.resource_name
    url = self.__class__.rest_base_url()
    if self.id is not None:
        return "%s/%s/%s" % (url, name, self.id)
    return "%s/%s" % (url, name)

def get_resource_url_for_child_type(self, nurest_object_type):
    """ Get the resource url for the nurest_object type """
    return "%s/%s" % (self.get_resource_url(), nurest_object_type.resource_name)

def instantiate_child(self, nurest_object, from_template, response_choice=None, async=False, callback=None, commit=True):
    """ Instantiate an nurest_object from a template object
        Args:
            nurest_object: the NURESTObject object to add
            from_template: the NURESTObject template object
            callback: callback containing the object and the connection
        Returns:
            Returns the object and connection (object, connection)
        Example:
            >>> parent_entity = NUParentEntity(id="xxxx-xxxx-xxx-xxxx") # create a NUParentEntity with an existing ID (or retrieve one)
            >>> other_entity_template = NUOtherEntityTemplate(id="yyyy-yyyy-yyyy-yyyy") # create a NUOtherEntityTemplate with an existing ID (or retrieve one)
            >>> other_entity_instance = NUOtherEntityInstance(name="my new instance") # create a new NUOtherEntityInstance to be intantiated from other_entity_template
            >>>
            >>> parent_entity.instantiate_child(other_entity_instance, other_entity_template) # instatiate the new domain in the server
    """
    # if nurest_object.id:
    #     raise InternalConsitencyError("Cannot instantiate a child that already has an ID: %s." % nurest_object)
    if not from_template.id:
        raise InternalConsitencyError("Cannot instantiate a child from a template with no ID: %s." % from_template)
    nurest_object.template_id = from_template.id
    return self._manage_child_object(nurest_object=nurest_object,
                                     async=async,
                                     method=HTTP_METHOD_POST,
                                     callback=callback,
                                     handler=self._did_create_child,
                                     response_choice=response_choice,
                                     commit=commit)

def is_owned_by_current_user(self):
    """ Check if the current user owns the object """
    from bambou.nurest_root_object import NURESTRootObject
    root_object = NURESTRootObject.get_default_root_object()
    return self._owner == root_object.id

def is_valid(self):
    """
    """
    return len(self.errors) == 0

@classmethod
def object_with_id(cls, id):
    """ Get a new object with the given id
        Returns:
            Returns a new instance with specified id
    """
    new_object = cls()
    new_object.id = id
    return new_object

def parent_for_matching_rest_name(self, rest_names):
    """ Return parent that matches a rest name """
    parent = self
    while parent:
        if parent.rest_name in rest_names:
            return parent
        parent = parent.parent_object
    return None

def register_fetcher(self, fetcher, rest_name):
    """ Register a children fetcher
    """
    self._fetchers_registry[rest_name] = fetcher

def remove_child(self, child):
    """ Remove a child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    target_child = None
    for local_child in children:
        if local_child.id == child.id:
            target_child = local_child
            break
    if target_child:
        target_child.parent_object = None
        children.remove(target_child)

@classmethod
def rest_base_url(cls):
    """ Override this method to set object base url """
    controller = _NURESTSessionCurrentContext.session.login_controller
    return controller.url

def rest_equals(self, rest_object):
    """ Compare objects REST attributes
    """
    if not self.equals(rest_object):
        return False
    return self.to_dict() == rest_object.to_dict()

def save(self, response_choice=None, async=False, callback=None):
    """ Update object and call given callback in case of async call
        Args:
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Example:
            >>> entity.name = "My Super Object"
            >>> entity.save() # will save the new name in the server
    """
    return self._manage_child_object(nurest_object=self, method=HTTP_METHOD_PUT, async=async, callback=callback, response_choice=response_choice)

def send_request(self, request, async=False, local_callback=None, remote_callback=None, user_info=None):
    """ Sends a request, calls the local callback, then the remote callback in case of async call
        Args:
            request: The request to send
            local_callback: local method that will be triggered in case of async call
            remote_callback: remote moethd that will be triggered in case of async call
            user_info: contains additionnal information to carry during the request
        Returns:
            Returns the object and connection (object, connection)
    """
    callbacks = dict()
    if local_callback:
        callbacks['local'] = local_callback
    if remote_callback:
        callbacks['remote'] = remote_callback
    connection = NURESTConnection(request=request, async=async, callback=self._did_receive_response, callbacks=callbacks)
    connection.user_info = user_info
    return connection.start()

def to_dict(self):
    """ Converts the current object into a Dictionary using all exposed ReST attributes.
        Returns:
            dict: the dictionary containing all the exposed ReST attributes and their values.
        Example::
            >>> print entity.to_dict()
            {"name": "my entity", "description": "Hello World", "ID": "xxxx-xxx-xxxx-xxx", ...}
    """
    dictionary = dict()
    for local_name, attribute in self._attributes.iteritems():
        remote_name = attribute.remote_name
        if hasattr(self, local_name):
            value = getattr(self, local_name)
            # Removed to resolve issue http://mvjira.mv.usa.alcatel.com/browse/VSD-5940 (12/15/2014)
            # if isinstance(value, bool):
            #     value = int(value)
            if isinstance(value, NURESTObject):
                value = value.to_dict()
            if isinstance(value, list) and len(value) > 0 and isinstance(value[0], NURESTObject):
                tmp = list()
                for obj in value:
                    tmp.append(obj.to_dict())
                value = tmp
            dictionary[remote_name] = value
        else:
            pass  # pragma: no cover
    return dictionary

def update_child(self, child):
    """ Update child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    index = None
    for local_child in children:
        if local_child.id == child.id:
            index = children.index(local_child)
            break
    if index is not None:
        children[index] = child

def validate(self):
    """ Validate the current object attributes.
        Check all attributes and store errors
        Returns:
            Returns True if all attibutes of the object
            respect contraints. Returns False otherwise and
            store error in errors dict.
    """
    self._attribute_errors = dict()  # Reset validation errors
    for local_name, attribute in self._attributes.iteritems():
        value = getattr(self, local_name, None)
        if attribute.is_required and (value is None or value == ""):
            self._attribute_errors[local_name] = {'title': 'Invalid input',
                                                  'description': 'This value is mandatory.',
                                                  'remote_name': attribute.remote_name}
            continue
        if value is None:
            continue  # without error
        if type(value) != attribute.attribute_type:
            if attribute.attribute_type != str or type(value) != unicode:
                self._attribute_errors[local_name] = {'title': 'Wrong type',
                                                      'description': 'Attribute %s type should be %s but is %s' % (attribute.remote_name, attribute.attribute_type, type(value)),
                                                      'remote_name': attribute.remote_name}
                continue
        if attribute.min_length and len(value) < attribute.min_length:
            self._attribute_errors[local_name] = {'title': 'Invalid lenght',
                                                  'description': 'Attribute %s minimum size should be %s but is %s' % (attribute.remote_name, attribute.min_length, len(value)),
                                                  'remote_name': attribute.remote_name}
            continue
        if attribute.max_length and len(value) > attribute.max_length:
            self._attribute_errors[local_name] = {'title': 'Invalid lenght',
                                                  'description': 'Attribute %s maximum size should be %s but is %s' % (attribute.remote_name, attribute.max_length, len(value)),
                                                  'remote_name': attribute.remote_name}
            continue
        if attribute.choices and value not in attribute.choices:
            self._attribute_errors[local_name] = {'title': 'Invalid input',
                                                  'description': 'Invalid input',
                                                  'remote_name': attribute.remote_name}
            continue
    return self.is_valid()

def __init__(self, **kwargs):
    """ Initializes a BootstrapActivation instance
        Notes:
            You can specify all parameters while calling this methods.
            A special argument named `data` will enable you to load the
            object from a Python dictionary
        Examples:
            >>> bootstrapactivation = NUBootstrapActivation(id=u'xxxx-xxx-xxx-xxx', name=u'BootstrapActivation')
            >>> bootstrapactivation = NUBootstrapActivation(data=my_dict)
    """
    super(NUBootstrapActivation, self).__init__()
    # Read/Write Attributes
    
    self._cacert = None
    self._hash = None
    self._last_updated_by = None
    self._action = None
    self._seed = None
    self._cert = None
    self._entity_scope = None
    self._config_url = None
    self._tpm_owner_password = None
    self._srk_password = None
    self._vsd_time = None
    self._csr = None
    self._status = None
    self._external_id = None
    
    self.expose_attribute(local_name="cacert", remote_name="cacert", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="hash", remote_name="hash", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="last_updated_by", remote_name="lastUpdatedBy", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="action", remote_name="action", attribute_type=str, is_required=False, is_unique=False, choices=[u'AUTHENTICATE', u'BOOTSTRAP_COMPLETE', u'CERTIFICATE_RENEW', u'CERTIFICATE_REVOKE', u'CERTIFICATE_SIGNED', u'CONFIRM', u'INITIATE', u'INITIATE_RENEW', u'NEW_NCPE_AUTH_REQUIRED', u'NO_AUTH_REQUIRED', u'ROLLBACK', u'ROLLED_BACK', u'UNSPECIFIED'])
    self.expose_attribute(local_name="seed", remote_name="seed", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="cert", remote_name="cert", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="entity_scope", remote_name="entityScope", attribute_type=str, is_required=False, is_unique=False, choices=[u'ENTERPRISE', u'GLOBAL'])
    self.expose_attribute(local_name="config_url", remote_name="configURL", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="tpm_owner_password", remote_name="tpmOwnerPassword", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="srk_password", remote_name="srkPassword", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="vsd_time", remote_name="vsdTime", attribute_type=int, is_required=False, is_unique=False)
    self.expose_attribute(local_name="csr", remote_name="csr", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="status", remote_name="status", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="external_id", remote_name="externalID", attribute_type=str, is_required=False, is_unique=True)
    
    # Fetchers
    
    
    self.metadatas = NUMetadatasFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.global_metadatas = NUGlobalMetadatasFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    self._compute_args(**kwargs)

def add_child(self, child):
    """ Add a child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    if children is None:
        raise InternalConsitencyError('Could not find fetcher with name %s while adding %s in parent %s' % (rest_name, child, self))
    if child not in children:
        child.parent_object = self
        children.append(child)

def assign(self, objects, nurest_object_type, async=False, callback=None, commit=True):
    """ Reference a list of objects into the current resource
        Args:
            objects (list): list of NURESTObject to link
            nurest_object_type (type): Type of the object to link
            callback (function): Callback method that should be fired at the end
        Returns:
            Returns the current object and the connection (object, connection)
        Example:
            >>> entity.assign([entity1, entity2, entity3], NUEntity) # entity1, entity2 and entity3 are now part of the entity
    """
    ids = list()
    for nurest_object in objects:
        ids.append(nurest_object.id)
    url = self.get_resource_url_for_child_type(nurest_object_type)
    request = NURESTRequest(method=HTTP_METHOD_PUT, url=url, data=ids)
    user_info = {'nurest_objects': objects, 'commit': commit}
    if async:
        return self.send_request(request=request,
                                 async=async,
                                 local_callback=self._did_perform_standard_operation,
                                 remote_callback=callback,
                                 user_info=user_info)
    else:
        connection = self.send_request(request=request,
                                       user_info=user_info)
        return self._did_perform_standard_operation(connection)

def copy(self):
    """ Returns a copy of the current object
        Returns:
            A copy of the given object
        Example::
            >>> print entity.to_dict()
            
    """
    return self.__class__(data=self.to_dict())

def create_child(self, nurest_object, response_choice=None, async=False, callback=None, commit=True):
    """ Add given nurest_object to the current object
        For example, to add a child into a parent, you can call
        parent.create_child(nurest_object=child)
        Args:
            nurest_object (bambou.NURESTObject): the NURESTObject object to add
            response_choice (int): Automatically send a response choice when confirmation is needed
            async (bool): should the request be done asynchronously or not
            callback (function): callback containing the object and the connection
        Returns:
            Returns the object and connection (object, connection)
        Example:
            >>> entity = NUEntity(name="Super Entity")
            >>> parent_entity.create_child(entity) # the new entity as been created in the parent_entity
    """
    # if nurest_object.id:
    #     raise InternalConsitencyError("Cannot create a child that already has an ID: %s." % nurest_object)
    return self._manage_child_object(nurest_object=nurest_object,
                                     async=async,
                                     method=HTTP_METHOD_POST,
                                     callback=callback,
                                     handler=self._did_create_child,
                                     response_choice=response_choice,
                                     commit=commit)

def delete(self, response_choice=1, async=False, callback=None):
    """ Delete object and call given callback in case of call.
        Args:
            response_choice (int): Automatically send a response choice when confirmation is needed
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Example:
            >>> entity.delete() # will delete the enterprise from the server
    """
    return self._manage_child_object(nurest_object=self, method=HTTP_METHOD_DELETE, async=async, callback=callback, response_choice=response_choice)

def equals(self, rest_object):
    """ Compare with another object """
    if self._is_dirty:
        return False
    if rest_object is None:
        return False
    if not isinstance(rest_object, NURESTObject):
        raise TypeError('The object is not a NURESTObject %s' % rest_object)
    if self.rest_name != rest_object.rest_name:
        return False
    if self.id and rest_object.id:
        return self.id == rest_object.id
    if self.local_id and rest_object.local_id:
        return self.local_id == rest_object.local_id
    return False

def expose_attribute(self, local_name, attribute_type, remote_name=None, display_name=None, is_required=False, is_readonly=False, max_length=None, min_length=None, is_identifier=False, choices=None, is_unique=False, is_email=False, is_login=False, is_editable=True, is_password=False, can_order=False, can_search=False):
    """ Expose local_name as remote_name
        An exposed attribute `local_name` will be sent within the HTTP request as
        a `remote_name`
    """
    if remote_name is None:
        remote_name = local_name
    if display_name is None:
        display_name = local_name
    attribute = NURemoteAttribute(local_name=local_name, remote_name=remote_name, attribute_type=attribute_type)
    attribute.display_name = display_name
    attribute.is_required = is_required
    attribute.is_readonly = is_readonly
    attribute.min_length = min_length
    attribute.max_length = max_length
    attribute.is_editable = is_editable
    attribute.is_identifier = is_identifier
    attribute.choices = choices
    attribute.is_unique = is_unique
    attribute.is_email = is_email
    attribute.is_login = is_login
    attribute.is_password = is_password
    attribute.can_order = can_order
    attribute.can_search = can_search
    self._attributes[local_name] = attribute

def fetch(self, async=False, callback=None):
    """ Fetch all information about the current object
        Args:
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Returns:
            tuple: (current_fetcher, callee_parent, fetched_bjects, connection)
        Example:
            >>> entity = NUEntity(id="xxx-xxx-xxx-xxx")
            >>> entity.fetch() # will get the entity with id "xxx-xxx-xxx-xxx"
            >>> print entity.name
            "My Entity"
    """
    if self.id is None:
        raise InternalConsitencyError("Cannot fetch an object that does not have an ID")
    request = NURESTRequest(method=HTTP_METHOD_GET, url=self.get_resource_url())
    if async:
        return self.send_request(request=request, async=async, local_callback=self._did_retrieve, remote_callback=callback)
    else:
        connection = self.send_request(request=request)
        return self._did_retrieve(connection)

def fetcher_for_rest_name(self, rest_name):
    """ Returns the children fetcher for the given rest name
        Args:
            rest_name (string): the children rest name
        Returns:
            list: Returns the corresponding fetcher
        Example:
            >>> print entity.fetcher_for_rest_name(NUSubEntity.rest_name)
            
    """
    if rest_name not in self._fetchers_registry:
        return None
    return self._fetchers_registry[rest_name]

def from_dict(self, dictionary):
    """ Sets all the exposed ReST attribues from the given dictionary
        Args:
            dictionary (dict): dictionnary containing the raw object attributes and their values.
        Example:
            >>> info = {"name": "my group", "private": False}
            >>> group = NUGroup()
            >>> group.from_dict(info)
            >>> print "name: %s - private: %s" % (group.name, group.private)
            "name: my group - private: False"
    """
    for remote_name, remote_value in dictionary.iteritems():
        # Check if a local attribute is exposed with the remote_name
        # if no attribute is exposed, return None
        local_name = next((name for name, attribute in self._attributes.iteritems() if attribute.remote_name == remote_name), None)
        if local_name:
            setattr(self, local_name, remote_value)
        else:
            # print('Attribute %s could not be added to object %s' % (remote_name, self))
            pass  # pragma: no cover

def genealogic_ids(self):
    """ Get all genealogic ids
        Returns:
             A list of all parent ids
    """
    ids = []
    parent = self
    while parent:
        ids.append(parent.id)
        parent = parent.parent_object
    return ids

def genealogic_types(self):
    """ Get genealogic types
        Returns:
            Returns a list of all parent types
    """
    types = []
    parent = self
    while parent:
        types.append(parent.rest_name)
        parent = parent.parent_object
    return types

def genealogy_contains_id(self, id):
    """ Check if parents contains an object of type resource_name
        Args:
            id: the id of the resource to find
        Returns:
            Returns True if a parent with specific id has been found. False otherwise.
    """
    ids = self.genealogic_ids()
    return id in ids

def genealogy_contains_type(self, resource_name):
    """ Check if parents contains an object of type resource_name
        Args:
            resource_name: the name of the resource to find
        Returns:
            Returns True if a parent of type has been found. False otherwise.
    """
    resource_names = self.genealogic_types()
    return resource_name in resource_names

def get_attribute_infos(self, local_name):
    """ Get exposed attribute information
        Args:
            local_name: the attribute name
        Returns:
            A dictionary of all information
    """
    if local_name in self._attributes:
        return self._attributes[local_name]
    return None

def get_attributes(self):
    """ Get all attributes information
        Returns:
            Returns a dictionnary containing attribute information
    """
    return self._attributes.values()

def get_formated_creation_date(self, format='%b %Y %d %H:%I:%S'):
    """ Return creation date with a given format. Default is '%b %Y %d %H:%I:%S' """
    if not self._creation_date:
        return None
    date = datetime.datetime.utcfromtimestamp(self._creation_date)
    return date.strftime(format)

def get_resource_url(self):
    """ Get resource complete url """
    name = self.__class__.resource_name
    url = self.__class__.rest_base_url()
    if self.id is not None:
        return "%s/%s/%s" % (url, name, self.id)
    return "%s/%s" % (url, name)

def get_resource_url_for_child_type(self, nurest_object_type):
    """ Get the resource url for the nurest_object type """
    return "%s/%s" % (self.get_resource_url(), nurest_object_type.resource_name)

def instantiate_child(self, nurest_object, from_template, response_choice=None, async=False, callback=None, commit=True):
    """ Instantiate an nurest_object from a template object
        Args:
            nurest_object: the NURESTObject object to add
            from_template: the NURESTObject template object
            callback: callback containing the object and the connection
        Returns:
            Returns the object and connection (object, connection)
        Example:
            >>> parent_entity = NUParentEntity(id="xxxx-xxxx-xxx-xxxx") # create a NUParentEntity with an existing ID (or retrieve one)
            >>> other_entity_template = NUOtherEntityTemplate(id="yyyy-yyyy-yyyy-yyyy") # create a NUOtherEntityTemplate with an existing ID (or retrieve one)
            >>> other_entity_instance = NUOtherEntityInstance(name="my new instance") # create a new NUOtherEntityInstance to be intantiated from other_entity_template
            >>>
            >>> parent_entity.instantiate_child(other_entity_instance, other_entity_template) # instatiate the new domain in the server
    """
    # if nurest_object.id:
    #     raise InternalConsitencyError("Cannot instantiate a child that already has an ID: %s." % nurest_object)
    if not from_template.id:
        raise InternalConsitencyError("Cannot instantiate a child from a template with no ID: %s." % from_template)
    nurest_object.template_id = from_template.id
    return self._manage_child_object(nurest_object=nurest_object,
                                     async=async,
                                     method=HTTP_METHOD_POST,
                                     callback=callback,
                                     handler=self._did_create_child,
                                     response_choice=response_choice,
                                     commit=commit)

def is_owned_by_current_user(self):
    """ Check if the current user owns the object """
    from bambou.nurest_root_object import NURESTRootObject
    root_object = NURESTRootObject.get_default_root_object()
    return self._owner == root_object.id

def is_valid(self):
    """
    """
    return len(self.errors) == 0

@classmethod
def object_with_id(cls, id):
    """ Get a new object with the given id
        Returns:
            Returns a new instance with specified id
    """
    new_object = cls()
    new_object.id = id
    return new_object

def parent_for_matching_rest_name(self, rest_names):
    """ Return parent that matches a rest name """
    parent = self
    while parent:
        if parent.rest_name in rest_names:
            return parent
        parent = parent.parent_object
    return None

def register_fetcher(self, fetcher, rest_name):
    """ Register a children fetcher
    """
    self._fetchers_registry[rest_name] = fetcher

def remove_child(self, child):
    """ Remove a child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    target_child = None
    for local_child in children:
        if local_child.id == child.id:
            target_child = local_child
            break
    if target_child:
        target_child.parent_object = None
        children.remove(target_child)

@classmethod
def rest_base_url(cls):
    """ Override this method to set object base url """
    controller = _NURESTSessionCurrentContext.session.login_controller
    return controller.url

def rest_equals(self, rest_object):
    """ Compare objects REST attributes
    """
    if not self.equals(rest_object):
        return False
    return self.to_dict() == rest_object.to_dict()

def save(self, response_choice=None, async=False, callback=None):
    """ Update object and call given callback in case of async call
        Args:
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Example:
            >>> entity.name = "My Super Object"
            >>> entity.save() # will save the new name in the server
    """
    return self._manage_child_object(nurest_object=self, method=HTTP_METHOD_PUT, async=async, callback=callback, response_choice=response_choice)

def send_request(self, request, async=False, local_callback=None, remote_callback=None, user_info=None):
    """ Sends a request, calls the local callback, then the remote callback in case of async call
        Args:
            request: The request to send
            local_callback: local method that will be triggered in case of async call
            remote_callback: remote moethd that will be triggered in case of async call
            user_info: contains additionnal information to carry during the request
        Returns:
            Returns the object and connection (object, connection)
    """
    callbacks = dict()
    if local_callback:
        callbacks['local'] = local_callback
    if remote_callback:
        callbacks['remote'] = remote_callback
    connection = NURESTConnection(request=request, async=async, callback=self._did_receive_response, callbacks=callbacks)
    connection.user_info = user_info
    return connection.start()

def to_dict(self):
    """ Converts the current object into a Dictionary using all exposed ReST attributes.
        Returns:
            dict: the dictionary containing all the exposed ReST attributes and their values.
        Example::
            >>> print entity.to_dict()
            {"name": "my entity", "description": "Hello World", "ID": "xxxx-xxx-xxxx-xxx", ...}
    """
    dictionary = dict()
    for local_name, attribute in self._attributes.iteritems():
        remote_name = attribute.remote_name
        if hasattr(self, local_name):
            value = getattr(self, local_name)
            # Removed to resolve issue http://mvjira.mv.usa.alcatel.com/browse/VSD-5940 (12/15/2014)
            # if isinstance(value, bool):
            #     value = int(value)
            if isinstance(value, NURESTObject):
                value = value.to_dict()
            if isinstance(value, list) and len(value) > 0 and isinstance(value[0], NURESTObject):
                tmp = list()
                for obj in value:
                    tmp.append(obj.to_dict())
                value = tmp
            dictionary[remote_name] = value
        else:
            pass  # pragma: no cover
    return dictionary

def update_child(self, child):
    """ Update child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    index = None
    for local_child in children:
        if local_child.id == child.id:
            index = children.index(local_child)
            break
    if index is not None:
        children[index] = child

def validate(self):
    """ Validate the current object attributes.
        Check all attributes and store errors
        Returns:
            Returns True if all attibutes of the object
            respect contraints. Returns False otherwise and
            store error in errors dict.
    """
    self._attribute_errors = dict()  # Reset validation errors
    for local_name, attribute in self._attributes.iteritems():
        value = getattr(self, local_name, None)
        if attribute.is_required and (value is None or value == ""):
            self._attribute_errors[local_name] = {'title': 'Invalid input',
                                                  'description': 'This value is mandatory.',
                                                  'remote_name': attribute.remote_name}
            continue
        if value is None:
            continue  # without error
        if type(value) != attribute.attribute_type:
            if attribute.attribute_type != str or type(value) != unicode:
                self._attribute_errors[local_name] = {'title': 'Wrong type',
                                                      'description': 'Attribute %s type should be %s but is %s' % (attribute.remote_name, attribute.attribute_type, type(value)),
                                                      'remote_name': attribute.remote_name}
                continue
        if attribute.min_length and len(value) < attribute.min_length:
            self._attribute_errors[local_name] = {'title': 'Invalid lenght',
                                                  'description': 'Attribute %s minimum size should be %s but is %s' % (attribute.remote_name, attribute.min_length, len(value)),
                                                  'remote_name': attribute.remote_name}
            continue
        if attribute.max_length and len(value) > attribute.max_length:
            self._attribute_errors[local_name] = {'title': 'Invalid lenght',
                                                  'description': 'Attribute %s maximum size should be %s but is %s' % (attribute.remote_name, attribute.max_length, len(value)),
                                                  'remote_name': attribute.remote_name}
            continue
        if attribute.choices and value not in attribute.choices:
            self._attribute_errors[local_name] = {'title': 'Invalid input',
                                                  'description': 'Invalid input',
                                                  'remote_name': attribute.remote_name}
            continue
    return self.is_valid()

def __init__(self, **kwargs):
    """ Initializes a BridgeInterface instance
        Notes:
            You can specify all parameters while calling this methods.
            A special argument named `data` will enable you to load the
            object from a Python dictionary
        Examples:
            >>> bridgeinterface = NUBridgeInterface(id=u'xxxx-xxx-xxx-xxx', name=u'BridgeInterface')
            >>> bridgeinterface = NUBridgeInterface(data=my_dict)
    """
    super(NUBridgeInterface, self).__init__()
    # Read/Write Attributes
    
    self._vport_id = None
    self._vport_name = None
    self._name = None
    self._last_updated_by = None
    self._gateway = None
    self._netmask = None
    self._network_name = None
    self._tier_id = None
    self._entity_scope = None
    self._policy_decision_id = None
    self._domain_id = None
    self._domain_name = None
    self._zone_id = None
    self._zone_name = None
    self._associated_floating_ip_address = None
    self._attached_network_id = None
    self._attached_network_type = None
    self._external_id = None
    
    self.expose_attribute(local_name="vport_id", remote_name="VPortID", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="vport_name", remote_name="VPortName", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="name", remote_name="name", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="last_updated_by", remote_name="lastUpdatedBy", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="gateway", remote_name="gateway", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="netmask", remote_name="netmask", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="network_name", remote_name="networkName", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="tier_id", remote_name="tierID", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="entity_scope", remote_name="entityScope", attribute_type=str, is_required=False, is_unique=False, choices=[u'ENTERPRISE', u'GLOBAL'])
    self.expose_attribute(local_name="policy_decision_id", remote_name="policyDecisionID", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="domain_id", remote_name="domainID", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="domain_name", remote_name="domainName", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="zone_id", remote_name="zoneID", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="zone_name", remote_name="zoneName", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="associated_floating_ip_address", remote_name="associatedFloatingIPAddress", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="attached_network_id", remote_name="attachedNetworkID", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="attached_network_type", remote_name="attachedNetworkType", attribute_type=str, is_required=False, is_unique=False, choices=[u'L2DOMAIN', u'SUBNET'])
    self.expose_attribute(local_name="external_id", remote_name="externalID", attribute_type=str, is_required=False, is_unique=True)
    
    # Fetchers
    
    
    self.tcas = NUTCAsFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.redirection_targets = NURedirectionTargetsFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.metadatas = NUMetadatasFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.dhcp_options = NUDHCPOptionsFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.global_metadatas = NUGlobalMetadatasFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.policy_decisions = NUPolicyDecisionsFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.policy_groups = NUPolicyGroupsFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.qoss = NUQOSsFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.statistics = NUStatisticsFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.event_logs = NUEventLogsFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    self._compute_args(**kwargs)

def add_child(self, child):
    """ Add a child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    if children is None:
        raise InternalConsitencyError('Could not find fetcher with name %s while adding %s in parent %s' % (rest_name, child, self))
    if child not in children:
        child.parent_object = self
        children.append(child)

def assign(self, objects, nurest_object_type, async=False, callback=None, commit=True):
    """ Reference a list of objects into the current resource
        Args:
            objects (list): list of NURESTObject to link
            nurest_object_type (type): Type of the object to link
            callback (function): Callback method that should be fired at the end
        Returns:
            Returns the current object and the connection (object, connection)
        Example:
            >>> entity.assign([entity1, entity2, entity3], NUEntity) # entity1, entity2 and entity3 are now part of the entity
    """
    ids = list()
    for nurest_object in objects:
        ids.append(nurest_object.id)
    url = self.get_resource_url_for_child_type(nurest_object_type)
    request = NURESTRequest(method=HTTP_METHOD_PUT, url=url, data=ids)
    user_info = {'nurest_objects': objects, 'commit': commit}
    if async:
        return self.send_request(request=request,
                                 async=async,
                                 local_callback=self._did_perform_standard_operation,
                                 remote_callback=callback,
                                 user_info=user_info)
    else:
        connection = self.send_request(request=request,
                                       user_info=user_info)
        return self._did_perform_standard_operation(connection)

def copy(self):
    """ Returns a copy of the current object
        Returns:
            A copy of the given object
        Example::
            >>> print entity.to_dict()
            
    """
    return self.__class__(data=self.to_dict())

def create_child(self, nurest_object, response_choice=None, async=False, callback=None, commit=True):
    """ Add given nurest_object to the current object
        For example, to add a child into a parent, you can call
        parent.create_child(nurest_object=child)
        Args:
            nurest_object (bambou.NURESTObject): the NURESTObject object to add
            response_choice (int): Automatically send a response choice when confirmation is needed
            async (bool): should the request be done asynchronously or not
            callback (function): callback containing the object and the connection
        Returns:
            Returns the object and connection (object, connection)
        Example:
            >>> entity = NUEntity(name="Super Entity")
            >>> parent_entity.create_child(entity) # the new entity as been created in the parent_entity
    """
    # if nurest_object.id:
    #     raise InternalConsitencyError("Cannot create a child that already has an ID: %s." % nurest_object)
    return self._manage_child_object(nurest_object=nurest_object,
                                     async=async,
                                     method=HTTP_METHOD_POST,
                                     callback=callback,
                                     handler=self._did_create_child,
                                     response_choice=response_choice,
                                     commit=commit)

def delete(self, response_choice=1, async=False, callback=None):
    """ Delete object and call given callback in case of call.
        Args:
            response_choice (int): Automatically send a response choice when confirmation is needed
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Example:
            >>> entity.delete() # will delete the enterprise from the server
    """
    return self._manage_child_object(nurest_object=self, method=HTTP_METHOD_DELETE, async=async, callback=callback, response_choice=response_choice)

def equals(self, rest_object):
    """ Compare with another object """
    if self._is_dirty:
        return False
    if rest_object is None:
        return False
    if not isinstance(rest_object, NURESTObject):
        raise TypeError('The object is not a NURESTObject %s' % rest_object)
    if self.rest_name != rest_object.rest_name:
        return False
    if self.id and rest_object.id:
        return self.id == rest_object.id
    if self.local_id and rest_object.local_id:
        return self.local_id == rest_object.local_id
    return False

def expose_attribute(self, local_name, attribute_type, remote_name=None, display_name=None, is_required=False, is_readonly=False, max_length=None, min_length=None, is_identifier=False, choices=None, is_unique=False, is_email=False, is_login=False, is_editable=True, is_password=False, can_order=False, can_search=False):
    """ Expose local_name as remote_name
        An exposed attribute `local_name` will be sent within the HTTP request as
        a `remote_name`
    """
    if remote_name is None:
        remote_name = local_name
    if display_name is None:
        display_name = local_name
    attribute = NURemoteAttribute(local_name=local_name, remote_name=remote_name, attribute_type=attribute_type)
    attribute.display_name = display_name
    attribute.is_required = is_required
    attribute.is_readonly = is_readonly
    attribute.min_length = min_length
    attribute.max_length = max_length
    attribute.is_editable = is_editable
    attribute.is_identifier = is_identifier
    attribute.choices = choices
    attribute.is_unique = is_unique
    attribute.is_email = is_email
    attribute.is_login = is_login
    attribute.is_password = is_password
    attribute.can_order = can_order
    attribute.can_search = can_search
    self._attributes[local_name] = attribute

def fetch(self, async=False, callback=None):
    """ Fetch all information about the current object
        Args:
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Returns:
            tuple: (current_fetcher, callee_parent, fetched_bjects, connection)
        Example:
            >>> entity = NUEntity(id="xxx-xxx-xxx-xxx")
            >>> entity.fetch() # will get the entity with id "xxx-xxx-xxx-xxx"
            >>> print entity.name
            "My Entity"
    """
    if self.id is None:
        raise InternalConsitencyError("Cannot fetch an object that does not have an ID")
    request = NURESTRequest(method=HTTP_METHOD_GET, url=self.get_resource_url())
    if async:
        return self.send_request(request=request, async=async, local_callback=self._did_retrieve, remote_callback=callback)
    else:
        connection = self.send_request(request=request)
        return self._did_retrieve(connection)

def fetcher_for_rest_name(self, rest_name):
    """ Returns the children fetcher for the given rest name
        Args:
            rest_name (string): the children rest name
        Returns:
            list: Returns the corresponding fetcher
        Example:
            >>> print entity.fetcher_for_rest_name(NUSubEntity.rest_name)
            
    """
    if rest_name not in self._fetchers_registry:
        return None
    return self._fetchers_registry[rest_name]

def from_dict(self, dictionary):
    """ Sets all the exposed ReST attribues from the given dictionary
        Args:
            dictionary (dict): dictionnary containing the raw object attributes and their values.
        Example:
            >>> info = {"name": "my group", "private": False}
            >>> group = NUGroup()
            >>> group.from_dict(info)
            >>> print "name: %s - private: %s" % (group.name, group.private)
            "name: my group - private: False"
    """
    for remote_name, remote_value in dictionary.iteritems():
        # Check if a local attribute is exposed with the remote_name
        # if no attribute is exposed, return None
        local_name = next((name for name, attribute in self._attributes.iteritems() if attribute.remote_name == remote_name), None)
        if local_name:
            setattr(self, local_name, remote_value)
        else:
            # print('Attribute %s could not be added to object %s' % (remote_name, self))
            pass  # pragma: no cover

def genealogic_ids(self):
    """ Get all genealogic ids
        Returns:
             A list of all parent ids
    """
    ids = []
    parent = self
    while parent:
        ids.append(parent.id)
        parent = parent.parent_object
    return ids

def genealogic_types(self):
    """ Get genealogic types
        Returns:
            Returns a list of all parent types
    """
    types = []
    parent = self
    while parent:
        types.append(parent.rest_name)
        parent = parent.parent_object
    return types

def genealogy_contains_id(self, id):
    """ Check if parents contains an object of type resource_name
        Args:
            id: the id of the resource to find
        Returns:
            Returns True if a parent with specific id has been found. False otherwise.
    """
    ids = self.genealogic_ids()
    return id in ids

def genealogy_contains_type(self, resource_name):
    """ Check if parents contains an object of type resource_name
        Args:
            resource_name: the name of the resource to find
        Returns:
            Returns True if a parent of type has been found. False otherwise.
    """
    resource_names = self.genealogic_types()
    return resource_name in resource_names

def get_attribute_infos(self, local_name):
    """ Get exposed attribute information
        Args:
            local_name: the attribute name
        Returns:
            A dictionary of all information
    """
    if local_name in self._attributes:
        return self._attributes[local_name]
    return None

def get_attributes(self):
    """ Get all attributes information
        Returns:
            Returns a dictionnary containing attribute information
    """
    return self._attributes.values()

def get_formated_creation_date(self, format='%b %Y %d %H:%I:%S'):
    """ Return creation date with a given format. Default is '%b %Y %d %H:%I:%S' """
    if not self._creation_date:
        return None
    date = datetime.datetime.utcfromtimestamp(self._creation_date)
    return date.strftime(format)

def get_resource_url(self):
    """ Get resource complete url """
    name = self.__class__.resource_name
    url = self.__class__.rest_base_url()
    if self.id is not None:
        return "%s/%s/%s" % (url, name, self.id)
    return "%s/%s" % (url, name)

def get_resource_url_for_child_type(self, nurest_object_type):
    """ Get the resource url for the nurest_object type """
    return "%s/%s" % (self.get_resource_url(), nurest_object_type.resource_name)

def instantiate_child(self, nurest_object, from_template, response_choice=None, async=False, callback=None, commit=True):
    """ Instantiate an nurest_object from a template object
        Args:
            nurest_object: the NURESTObject object to add
            from_template: the NURESTObject template object
            callback: callback containing the object and the connection
        Returns:
            Returns the object and connection (object, connection)
        Example:
            >>> parent_entity = NUParentEntity(id="xxxx-xxxx-xxx-xxxx") # create a NUParentEntity with an existing ID (or retrieve one)
            >>> other_entity_template = NUOtherEntityTemplate(id="yyyy-yyyy-yyyy-yyyy") # create a NUOtherEntityTemplate with an existing ID (or retrieve one)
            >>> other_entity_instance = NUOtherEntityInstance(name="my new instance") # create a new NUOtherEntityInstance to be intantiated from other_entity_template
            >>>
            >>> parent_entity.instantiate_child(other_entity_instance, other_entity_template) # instatiate the new domain in the server
    """
    # if nurest_object.id:
    #     raise InternalConsitencyError("Cannot instantiate a child that already has an ID: %s." % nurest_object)
    if not from_template.id:
        raise InternalConsitencyError("Cannot instantiate a child from a template with no ID: %s." % from_template)
    nurest_object.template_id = from_template.id
    return self._manage_child_object(nurest_object=nurest_object,
                                     async=async,
                                     method=HTTP_METHOD_POST,
                                     callback=callback,
                                     handler=self._did_create_child,
                                     response_choice=response_choice,
                                     commit=commit)

def is_owned_by_current_user(self):
    """ Check if the current user owns the object """
    from bambou.nurest_root_object import NURESTRootObject
    root_object = NURESTRootObject.get_default_root_object()
    return self._owner == root_object.id

def is_valid(self):
    """
    """
    return len(self.errors) == 0

@classmethod
def object_with_id(cls, id):
    """ Get a new object with the given id
        Returns:
            Returns a new instance with specified id
    """
    new_object = cls()
    new_object.id = id
    return new_object

def parent_for_matching_rest_name(self, rest_names):
    """ Return parent that matches a rest name """
    parent = self
    while parent:
        if parent.rest_name in rest_names:
            return parent
        parent = parent.parent_object
    return None

def register_fetcher(self, fetcher, rest_name):
    """ Register a children fetcher
    """
    self._fetchers_registry[rest_name] = fetcher

def remove_child(self, child):
    """ Remove a child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    target_child = None
    for local_child in children:
        if local_child.id == child.id:
            target_child = local_child
            break
    if target_child:
        target_child.parent_object = None
        children.remove(target_child)

@classmethod
def rest_base_url(cls):
    """ Override this method to set object base url """
    controller = _NURESTSessionCurrentContext.session.login_controller
    return controller.url

def rest_equals(self, rest_object):
    """ Compare objects REST attributes
    """
    if not self.equals(rest_object):
        return False
    return self.to_dict() == rest_object.to_dict()

def save(self, response_choice=None, async=False, callback=None):
    """ Update object and call given callback in case of async call
        Args:
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Example:
            >>> entity.name = "My Super Object"
            >>> entity.save() # will save the new name in the server
    """
    return self._manage_child_object(nurest_object=self, method=HTTP_METHOD_PUT, async=async, callback=callback, response_choice=response_choice)

def send_request(self, request, async=False, local_callback=None, remote_callback=None, user_info=None):
    """ Sends a request, calls the local callback, then the remote callback in case of async call
        Args:
            request: The request to send
            local_callback: local method that will be triggered in case of async call
            remote_callback: remote moethd that will be triggered in case of async call
            user_info: contains additionnal information to carry during the request
        Returns:
            Returns the object and connection (object, connection)
    """
    callbacks = dict()
    if local_callback:
        callbacks['local'] = local_callback
    if remote_callback:
        callbacks['remote'] = remote_callback
    connection = NURESTConnection(request=request, async=async, callback=self._did_receive_response, callbacks=callbacks)
    connection.user_info = user_info
    return connection.start()

def to_dict(self):
    """ Converts the current object into a Dictionary using all exposed ReST attributes.
        Returns:
            dict: the dictionary containing all the exposed ReST attributes and their values.
        Example::
            >>> print entity.to_dict()
            {"name": "my entity", "description": "Hello World", "ID": "xxxx-xxx-xxxx-xxx", ...}
    """
    dictionary = dict()
    for local_name, attribute in self._attributes.iteritems():
        remote_name = attribute.remote_name
        if hasattr(self, local_name):
            value = getattr(self, local_name)
            # Removed to resolve issue http://mvjira.mv.usa.alcatel.com/browse/VSD-5940 (12/15/2014)
            # if isinstance(value, bool):
            #     value = int(value)
            if isinstance(value, NURESTObject):
                value = value.to_dict()
            if isinstance(value, list) and len(value) > 0 and isinstance(value[0], NURESTObject):
                tmp = list()
                for obj in value:
                    tmp.append(obj.to_dict())
                value = tmp
            dictionary[remote_name] = value
        else:
            pass  # pragma: no cover
    return dictionary

def update_child(self, child):
    """ Update child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    index = None
    for local_child in children:
        if local_child.id == child.id:
            index = children.index(local_child)
            break
    if index is not None:
        children[index] = child

def validate(self):
    """ Validate the current object attributes.
        Check all attributes and store errors
        Returns:
            Returns True if all attibutes of the object
            respect contraints. Returns False otherwise and
            store error in errors dict.
    """
    self._attribute_errors = dict()  # Reset validation errors
    for local_name, attribute in self._attributes.iteritems():
        value = getattr(self, local_name, None)
        if attribute.is_required and (value is None or value == ""):
            self._attribute_errors[local_name] = {'title': 'Invalid input',
                                                  'description': 'This value is mandatory.',
                                                  'remote_name': attribute.remote_name}
            continue
        if value is None:
            continue  # without error
        if type(value) != attribute.attribute_type:
            if attribute.attribute_type != str or type(value) != unicode:
                self._attribute_errors[local_name] = {'title': 'Wrong type',
                                                      'description': 'Attribute %s type should be %s but is %s' % (attribute.remote_name, attribute.attribute_type, type(value)),
                                                      'remote_name': attribute.remote_name}
                continue
        if attribute.min_length and len(value) < attribute.min_length:
            self._attribute_errors[local_name] = {'title': 'Invalid lenght',
                                                  'description': 'Attribute %s minimum size should be %s but is %s' % (attribute.remote_name, attribute.min_length, len(value)),
                                                  'remote_name': attribute.remote_name}
            continue
        if attribute.max_length and len(value) > attribute.max_length:
            self._attribute_errors[local_name] = {'title': 'Invalid lenght',
                                                  'description': 'Attribute %s maximum size should be %s but is %s' % (attribute.remote_name, attribute.max_length, len(value)),
                                                  'remote_name': attribute.remote_name}
            continue
        if attribute.choices and value not in attribute.choices:
            self._attribute_errors[local_name] = {'title': 'Invalid input',
                                                  'description': 'Invalid input',
                                                  'remote_name': attribute.remote_name}
            continue
    return self.is_valid()

def __init__(self, **kwargs):
    """ Initializes a Certificate instance
        Notes:
            You can specify all parameters while calling this methods.
            A special argument named `data` will enable you to load the
            object from a Python dictionary
        Examples:
            >>> certificate = NUCertificate(id=u'xxxx-xxx-xxx-xxx', name=u'Certificate')
            >>> certificate = NUCertificate(data=my_dict)
    """
    super(NUCertificate, self).__init__()
    # Read/Write Attributes
    
    self._pem_encoded = None
    self._serial_number = None
    self._entity_scope = None
    self._issuer_dn = None
    self._subject_dn = None
    self._public_key = None
    self._external_id = None
    
    self.expose_attribute(local_name="pem_encoded", remote_name="pemEncoded", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="serial_number", remote_name="serialNumber", attribute_type=int, is_required=False, is_unique=False)
    self.expose_attribute(local_name="entity_scope", remote_name="entityScope", attribute_type=str, is_required=False, is_unique=False, choices=[u'ENTERPRISE', u'GLOBAL'])
    self.expose_attribute(local_name="issuer_dn", remote_name="issuerDN", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="subject_dn", remote_name="subjectDN", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="public_key", remote_name="publicKey", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="external_id", remote_name="externalID", attribute_type=str, is_required=False, is_unique=True)
    
    # Fetchers
    
    
    self.metadatas = NUMetadatasFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.global_metadatas = NUGlobalMetadatasFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    self._compute_args(**kwargs)

def add_child(self, child):
    """ Add a child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    if children is None:
        raise InternalConsitencyError('Could not find fetcher with name %s while adding %s in parent %s' % (rest_name, child, self))
    if child not in children:
        child.parent_object = self
        children.append(child)

def assign(self, objects, nurest_object_type, async=False, callback=None, commit=True):
    """ Reference a list of objects into the current resource
        Args:
            objects (list): list of NURESTObject to link
            nurest_object_type (type): Type of the object to link
            callback (function): Callback method that should be fired at the end
        Returns:
            Returns the current object and the connection (object, connection)
        Example:
            >>> entity.assign([entity1, entity2, entity3], NUEntity) # entity1, entity2 and entity3 are now part of the entity
    """
    ids = list()
    for nurest_object in objects:
        ids.append(nurest_object.id)
    url = self.get_resource_url_for_child_type(nurest_object_type)
    request = NURESTRequest(method=HTTP_METHOD_PUT, url=url, data=ids)
    user_info = {'nurest_objects': objects, 'commit': commit}
    if async:
        return self.send_request(request=request,
                                 async=async,
                                 local_callback=self._did_perform_standard_operation,
                                 remote_callback=callback,
                                 user_info=user_info)
    else:
        connection = self.send_request(request=request,
                                       user_info=user_info)
        return self._did_perform_standard_operation(connection)

def copy(self):
    """ Returns a copy of the current object
        Returns:
            A copy of the given object
        Example::
            >>> print entity.to_dict()
            
    """
    return self.__class__(data=self.to_dict())

def create_child(self, nurest_object, response_choice=None, async=False, callback=None, commit=True):
    """ Add given nurest_object to the current object
        For example, to add a child into a parent, you can call
        parent.create_child(nurest_object=child)
        Args:
            nurest_object (bambou.NURESTObject): the NURESTObject object to add
            response_choice (int): Automatically send a response choice when confirmation is needed
            async (bool): should the request be done asynchronously or not
            callback (function): callback containing the object and the connection
        Returns:
            Returns the object and connection (object, connection)
        Example:
            >>> entity = NUEntity(name="Super Entity")
            >>> parent_entity.create_child(entity) # the new entity as been created in the parent_entity
    """
    # if nurest_object.id:
    #     raise InternalConsitencyError("Cannot create a child that already has an ID: %s." % nurest_object)
    return self._manage_child_object(nurest_object=nurest_object,
                                     async=async,
                                     method=HTTP_METHOD_POST,
                                     callback=callback,
                                     handler=self._did_create_child,
                                     response_choice=response_choice,
                                     commit=commit)

def delete(self, response_choice=1, async=False, callback=None):
    """ Delete object and call given callback in case of call.
        Args:
            response_choice (int): Automatically send a response choice when confirmation is needed
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Example:
            >>> entity.delete() # will delete the enterprise from the server
    """
    return self._manage_child_object(nurest_object=self, method=HTTP_METHOD_DELETE, async=async, callback=callback, response_choice=response_choice)

def equals(self, rest_object):
    """ Compare with another object """
    if self._is_dirty:
        return False
    if rest_object is None:
        return False
    if not isinstance(rest_object, NURESTObject):
        raise TypeError('The object is not a NURESTObject %s' % rest_object)
    if self.rest_name != rest_object.rest_name:
        return False
    if self.id and rest_object.id:
        return self.id == rest_object.id
    if self.local_id and rest_object.local_id:
        return self.local_id == rest_object.local_id
    return False

def expose_attribute(self, local_name, attribute_type, remote_name=None, display_name=None, is_required=False, is_readonly=False, max_length=None, min_length=None, is_identifier=False, choices=None, is_unique=False, is_email=False, is_login=False, is_editable=True, is_password=False, can_order=False, can_search=False):
    """ Expose local_name as remote_name
        An exposed attribute `local_name` will be sent within the HTTP request as
        a `remote_name`
    """
    if remote_name is None:
        remote_name = local_name
    if display_name is None:
        display_name = local_name
    attribute = NURemoteAttribute(local_name=local_name, remote_name=remote_name, attribute_type=attribute_type)
    attribute.display_name = display_name
    attribute.is_required = is_required
    attribute.is_readonly = is_readonly
    attribute.min_length = min_length
    attribute.max_length = max_length
    attribute.is_editable = is_editable
    attribute.is_identifier = is_identifier
    attribute.choices = choices
    attribute.is_unique = is_unique
    attribute.is_email = is_email
    attribute.is_login = is_login
    attribute.is_password = is_password
    attribute.can_order = can_order
    attribute.can_search = can_search
    self._attributes[local_name] = attribute

def fetch(self, async=False, callback=None):
    """ Fetch all information about the current object
        Args:
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Returns:
            tuple: (current_fetcher, callee_parent, fetched_bjects, connection)
        Example:
            >>> entity = NUEntity(id="xxx-xxx-xxx-xxx")
            >>> entity.fetch() # will get the entity with id "xxx-xxx-xxx-xxx"
            >>> print entity.name
            "My Entity"
    """
    if self.id is None:
        raise InternalConsitencyError("Cannot fetch an object that does not have an ID")
    request = NURESTRequest(method=HTTP_METHOD_GET, url=self.get_resource_url())
    if async:
        return self.send_request(request=request, async=async, local_callback=self._did_retrieve, remote_callback=callback)
    else:
        connection = self.send_request(request=request)
        return self._did_retrieve(connection)

def fetcher_for_rest_name(self, rest_name):
    """ Returns the children fetcher for the given rest name
        Args:
            rest_name (string): the children rest name
        Returns:
            list: Returns the corresponding fetcher
        Example:
            >>> print entity.fetcher_for_rest_name(NUSubEntity.rest_name)
            
    """
    if rest_name not in self._fetchers_registry:
        return None
    return self._fetchers_registry[rest_name]

def from_dict(self, dictionary):
    """ Sets all the exposed ReST attribues from the given dictionary
        Args:
            dictionary (dict): dictionnary containing the raw object attributes and their values.
        Example:
            >>> info = {"name": "my group", "private": False}
            >>> group = NUGroup()
            >>> group.from_dict(info)
            >>> print "name: %s - private: %s" % (group.name, group.private)
            "name: my group - private: False"
    """
    for remote_name, remote_value in dictionary.iteritems():
        # Check if a local attribute is exposed with the remote_name
        # if no attribute is exposed, return None
        local_name = next((name for name, attribute in self._attributes.iteritems() if attribute.remote_name == remote_name), None)
        if local_name:
            setattr(self, local_name, remote_value)
        else:
            # print('Attribute %s could not be added to object %s' % (remote_name, self))
            pass  # pragma: no cover

def genealogic_ids(self):
    """ Get all genealogic ids
        Returns:
             A list of all parent ids
    """
    ids = []
    parent = self
    while parent:
        ids.append(parent.id)
        parent = parent.parent_object
    return ids

def genealogic_types(self):
    """ Get genealogic types
        Returns:
            Returns a list of all parent types
    """
    types = []
    parent = self
    while parent:
        types.append(parent.rest_name)
        parent = parent.parent_object
    return types

def genealogy_contains_id(self, id):
    """ Check if parents contains an object of type resource_name
        Args:
            id: the id of the resource to find
        Returns:
            Returns True if a parent with specific id has been found. False otherwise.
    """
    ids = self.genealogic_ids()
    return id in ids

def genealogy_contains_type(self, resource_name):
    """ Check if parents contains an object of type resource_name
        Args:
            resource_name: the name of the resource to find
        Returns:
            Returns True if a parent of type has been found. False otherwise.
    """
    resource_names = self.genealogic_types()
    return resource_name in resource_names

def get_attribute_infos(self, local_name):
    """ Get exposed attribute information
        Args:
            local_name: the attribute name
        Returns:
            A dictionary of all information
    """
    if local_name in self._attributes:
        return self._attributes[local_name]
    return None

def get_attributes(self):
    """ Get all attributes information
        Returns:
            Returns a dictionnary containing attribute information
    """
    return self._attributes.values()

def get_formated_creation_date(self, format='%b %Y %d %H:%I:%S'):
    """ Return creation date with a given format. Default is '%b %Y %d %H:%I:%S' """
    if not self._creation_date:
        return None
    date = datetime.datetime.utcfromtimestamp(self._creation_date)
    return date.strftime(format)

def get_resource_url(self):
    """ Get resource complete url """
    name = self.__class__.resource_name
    url = self.__class__.rest_base_url()
    if self.id is not None:
        return "%s/%s/%s" % (url, name, self.id)
    return "%s/%s" % (url, name)

def get_resource_url_for_child_type(self, nurest_object_type):
    """ Get the resource url for the nurest_object type """
    return "%s/%s" % (self.get_resource_url(), nurest_object_type.resource_name)

def instantiate_child(self, nurest_object, from_template, response_choice=None, async=False, callback=None, commit=True):
    """ Instantiate an nurest_object from a template object
        Args:
            nurest_object: the NURESTObject object to add
            from_template: the NURESTObject template object
            callback: callback containing the object and the connection
        Returns:
            Returns the object and connection (object, connection)
        Example:
            >>> parent_entity = NUParentEntity(id="xxxx-xxxx-xxx-xxxx") # create a NUParentEntity with an existing ID (or retrieve one)
            >>> other_entity_template = NUOtherEntityTemplate(id="yyyy-yyyy-yyyy-yyyy") # create a NUOtherEntityTemplate with an existing ID (or retrieve one)
            >>> other_entity_instance = NUOtherEntityInstance(name="my new instance") # create a new NUOtherEntityInstance to be intantiated from other_entity_template
            >>>
            >>> parent_entity.instantiate_child(other_entity_instance, other_entity_template) # instatiate the new domain in the server
    """
    # if nurest_object.id:
    #     raise InternalConsitencyError("Cannot instantiate a child that already has an ID: %s." % nurest_object)
    if not from_template.id:
        raise InternalConsitencyError("Cannot instantiate a child from a template with no ID: %s." % from_template)
    nurest_object.template_id = from_template.id
    return self._manage_child_object(nurest_object=nurest_object,
                                     async=async,
                                     method=HTTP_METHOD_POST,
                                     callback=callback,
                                     handler=self._did_create_child,
                                     response_choice=response_choice,
                                     commit=commit)

def is_owned_by_current_user(self):
    """ Check if the current user owns the object """
    from bambou.nurest_root_object import NURESTRootObject
    root_object = NURESTRootObject.get_default_root_object()
    return self._owner == root_object.id

def is_valid(self):
    """
    """
    return len(self.errors) == 0

@classmethod
def object_with_id(cls, id):
    """ Get a new object with the given id
        Returns:
            Returns a new instance with specified id
    """
    new_object = cls()
    new_object.id = id
    return new_object

def parent_for_matching_rest_name(self, rest_names):
    """ Return parent that matches a rest name """
    parent = self
    while parent:
        if parent.rest_name in rest_names:
            return parent
        parent = parent.parent_object
    return None

def register_fetcher(self, fetcher, rest_name):
    """ Register a children fetcher
    """
    self._fetchers_registry[rest_name] = fetcher

def remove_child(self, child):
    """ Remove a child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    target_child = None
    for local_child in children:
        if local_child.id == child.id:
            target_child = local_child
            break
    if target_child:
        target_child.parent_object = None
        children.remove(target_child)

@classmethod
def rest_base_url(cls):
    """ Override this method to set object base url """
    controller = _NURESTSessionCurrentContext.session.login_controller
    return controller.url

def rest_equals(self, rest_object):
    """ Compare objects REST attributes
    """
    if not self.equals(rest_object):
        return False
    return self.to_dict() == rest_object.to_dict()

def save(self, response_choice=None, async=False, callback=None):
    """ Update object and call given callback in case of async call
        Args:
            async (bool): Boolean to make an asynchronous call. Default is False
            callback (function): Callback method that will be triggered in case of asynchronous call
        Example:
            >>> entity.name = "My Super Object"
            >>> entity.save() # will save the new name in the server
    """
    return self._manage_child_object(nurest_object=self, method=HTTP_METHOD_PUT, async=async, callback=callback, response_choice=response_choice)

def send_request(self, request, async=False, local_callback=None, remote_callback=None, user_info=None):
    """ Sends a request, calls the local callback, then the remote callback in case of async call
        Args:
            request: The request to send
            local_callback: local method that will be triggered in case of async call
            remote_callback: remote moethd that will be triggered in case of async call
            user_info: contains additionnal information to carry during the request
        Returns:
            Returns the object and connection (object, connection)
    """
    callbacks = dict()
    if local_callback:
        callbacks['local'] = local_callback
    if remote_callback:
        callbacks['remote'] = remote_callback
    connection = NURESTConnection(request=request, async=async, callback=self._did_receive_response, callbacks=callbacks)
    connection.user_info = user_info
    return connection.start()

def to_dict(self):
    """ Converts the current object into a Dictionary using all exposed ReST attributes.
        Returns:
            dict: the dictionary containing all the exposed ReST attributes and their values.
        Example::
            >>> print entity.to_dict()
            {"name": "my entity", "description": "Hello World", "ID": "xxxx-xxx-xxxx-xxx", ...}
    """
    dictionary = dict()
    for local_name, attribute in self._attributes.iteritems():
        remote_name = attribute.remote_name
        if hasattr(self, local_name):
            value = getattr(self, local_name)
            # Removed to resolve issue http://mvjira.mv.usa.alcatel.com/browse/VSD-5940 (12/15/2014)
            # if isinstance(value, bool):
            #     value = int(value)
            if isinstance(value, NURESTObject):
                value = value.to_dict()
            if isinstance(value, list) and len(value) > 0 and isinstance(value[0], NURESTObject):
                tmp = list()
                for obj in value:
                    tmp.append(obj.to_dict())
                value = tmp
            dictionary[remote_name] = value
        else:
            pass  # pragma: no cover
    return dictionary

def update_child(self, child):
    """ Update child """
    rest_name = child.rest_name
    children = self.fetcher_for_rest_name(rest_name)
    index = None
    for local_child in children:
        if local_child.id == child.id:
            index = children.index(local_child)
            break
    if index is not None:
        children[index] = child

def validate(self):
    """ Validate the current object attributes.
        Check all attributes and store errors
        Returns:
            Returns True if all attibutes of the object
            respect contraints. Returns False otherwise and
            store error in errors dict.
    """
    self._attribute_errors = dict()  # Reset validation errors
    for local_name, attribute in self._attributes.iteritems():
        value = getattr(self, local_name, None)
        if attribute.is_required and (value is None or value == ""):
            self._attribute_errors[local_name] = {'title': 'Invalid input',
                                                  'description': 'This value is mandatory.',
                                                  'remote_name': attribute.remote_name}
            continue
        if value is None:
            continue  # without error
        if type(value) != attribute.attribute_type:
            if attribute.attribute_type != str or type(value) != unicode:
                self._attribute_errors[local_name] = {'title': 'Wrong type',
                                                      'description': 'Attribute %s type should be %s but is %s' % (attribute.remote_name, attribute.attribute_type, type(value)),
                                                      'remote_name': attribute.remote_name}
                continue
        if attribute.min_length and len(value) < attribute.min_length:
            self._attribute_errors[local_name] = {'title': 'Invalid lenght',
                                                  'description': 'Attribute %s minimum size should be %s but is %s' % (attribute.remote_name, attribute.min_length, len(value)),
                                                  'remote_name': attribute.remote_name}
            continue
        if attribute.max_length and len(value) > attribute.max_length:
            self._attribute_errors[local_name] = {'title': 'Invalid lenght',
                                                  'description': 'Attribute %s maximum size should be %s but is %s' % (attribute.remote_name, attribute.max_length, len(value)),
                                                  'remote_name': attribute.remote_name}
            continue
        if attribute.choices and value not in attribute.choices:
            self._attribute_errors[local_name] = {'title': 'Invalid input',
                                                  'description': 'Invalid input',
                                                  'remote_name': attribute.remote_name}
            continue
    return self.is_valid()

def __init__(self, **kwargs):
    """ Initializes a CloudMgmtSystem instance
        Notes:
            You can specify all parameters while calling this methods.
            A special argument named `data` will enable you to load the
            object from a Python dictionary
        Examples:
            >>> cloudmgmtsystem = NUCloudMgmtSystem(id=u'xxxx-xxx-xxx-xxx', name=u'CloudMgmtSystem')
            >>> cloudmgmtsystem = NUCloudMgmtSystem(data=my_dict)
    """
    super(NUCloudMgmtSystem, self).__init__()
    # Read/Write Attributes
    
    self._name = None
    self._last_updated_by = None
    self._entity_scope = None
    self._external_id = None
    
    self.expose_attribute(local_name="name", remote_name="name", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="last_updated_by", remote_name="lastUpdatedBy", attribute_type=str, is_required=False, is_unique=False)
    self.expose_attribute(local_name="entity_scope", remote_name="entityScope", attribute_type=str, is_required=False, is_unique=False, choices=[u'ENTERPRISE', u'GLOBAL'])
    self.expose_attribute(local_name="external_id", remote_name="externalID", attribute_type=str, is_required=False, is_unique=True)
    
    # Fetchers
    
    
    self.metadatas = NUMetadatasFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    
    self.global_metadatas = NUGlobalMetadatasFetcher.fetcher_with_object(parent_object=self, relationship="child")
    
    self._compute_args(**kwargs)